diff --git a/cmd/modelsdk-codegen/audit.go b/cmd/modelsdk-codegen/audit.go new file mode 100644 index 00000000..89e14e2e --- /dev/null +++ b/cmd/modelsdk-codegen/audit.go @@ -0,0 +1,481 @@ +package main + +import ( + "database/sql" + "fmt" + "os" + "path/filepath" + "sort" + "strings" + + "go.mongodb.org/mongo-driver/bson" + _ "modernc.org/sqlite" +) + +// auditAliases scans MPR files for all $Type values, compares against the +// codegen registry, and reports gaps with heuristic alias suggestions. +// +// Usage: modelsdk-codegen -audit [ ...] +// +// For each gap, applies these heuristics to find a candidate match: +// 1. Namespace swap (ExportXmlAction$ → Microflows$) +// 2. Impl/Marker suffix strip/add +// 3. Prefix strip (ExportObjectMappingElement → ObjectMappingElement) +// 4. BSON field fingerprint matching against registered types +func auditAliases(paths []string, registeredTypes map[string]bool) { + // Collect all $Type values from BSON + bsonTypes := map[string]int{} + for _, p := range paths { + info, err := os.Stat(p) + if err != nil { + fmt.Fprintf(os.Stderr, "skip %s: %v\n", p, err) + continue + } + if info.IsDir() { + scanDir(p, bsonTypes) + } else { + scanSQLite(p, bsonTypes) + } + } + + // Find gaps + type gap struct { + TypeName string + Count int + Candidate string + Method string + } + var gaps []gap + for t, c := range bsonTypes { + if !registeredTypes[t] { + candidate, method := findCandidate(t, registeredTypes) + gaps = append(gaps, gap{t, c, candidate, method}) + } + } + sort.Slice(gaps, func(i, j int) bool { return gaps[i].Count > gaps[j].Count }) + + // Report + fmt.Printf("\nScanned %d unique $Type values from %d source(s)\n", len(bsonTypes), len(paths)) + fmt.Printf("Registered in codegen: %d\n", len(registeredTypes)) + fmt.Printf("Gaps: %d\n\n", len(gaps)) + + if len(gaps) == 0 { + fmt.Println("No gaps found — all BSON $Type values have registered factories.") + return + } + + // Separate into actionable (has candidate) and orphan (no candidate) + var actionable, orphan []gap + for _, g := range gaps { + if g.Candidate != "" { + actionable = append(actionable, g) + } else { + orphan = append(orphan, g) + } + } + + if len(actionable) > 0 { + fmt.Println("=== ALIAS CANDIDATES (add to storage_aliases in supplements.json) ===") + fmt.Println() + for _, g := range actionable { + fmt.Printf(" %6dx %-50s → %s (%s)\n", g.Count, g.TypeName, g.Candidate, g.Method) + } + fmt.Println() + fmt.Println("Suggested Go map entries:") + fmt.Println() + for _, g := range actionable { + fmt.Printf("\t\"%s\": \"%s\",\n", g.Candidate, g.TypeName) + } + fmt.Println() + } + + if len(orphan) > 0 { + fmt.Println("=== ORPHAN TYPES (no SDK match, will round-trip as element.Base) ===") + fmt.Println() + for _, g := range orphan { + fmt.Printf(" %6dx %s\n", g.Count, g.TypeName) + } + fmt.Println() + } +} + +// findCandidate applies heuristics to find a registered type that likely +// corresponds to the given BSON $Type. +func findCandidate(bsonType string, registered map[string]bool) (candidate, method string) { + ns, cls := splitType(bsonType) + + // 1. Impl suffix: FooImpl → Foo + if strings.HasSuffix(cls, "Impl") { + base := cls[:len(cls)-4] + if tryMatch(ns, base, registered) { + return ns + "$" + base, "strip-Impl" + } + // Try other namespaces + for _, altNs := range collectNamespaces(registered) { + if tryMatch(altNs, base, registered) { + return altNs + "$" + base, "strip-Impl+ns" + } + } + } + + // 2. Add Impl suffix: Foo → FooImpl + if tryMatch(ns, cls+"Impl", registered) { + return ns + "$" + cls + "Impl", "add-Impl" + } + + // 3. Marker suffix: FooMarker → Foo or Foo → FooMarker + if strings.HasSuffix(cls, "Marker") { + base := cls[:len(cls)-6] + if tryMatch(ns, base, registered) { + return ns + "$" + base, "strip-Marker" + } + } + + // 4. Namespace swap: check all registered namespaces + for _, altNs := range collectNamespaces(registered) { + if altNs == ns { + continue + } + if registered[altNs+"$"+cls] { + return altNs + "$" + cls, "ns-swap" + } + } + + // 5. Prefix strip: ExportObjectMappingElement → ObjectMappingElement + // Try removing common prefixes (Export, Import, Published, Consumed) + for _, prefix := range []string{"Export", "Import", "Published", "Consumed"} { + if strings.HasPrefix(cls, prefix) { + stripped := cls[len(prefix):] + if tryMatch(ns, stripped, registered) { + return ns + "$" + stripped, "strip-" + prefix + } + } + // Or add prefix + prefixed := prefix + cls + if tryMatch(ns, prefixed, registered) { + return ns + "$" + prefixed, "add-" + prefix + } + } + + // 6. Form/Page swap + swapped := cls + if strings.Contains(cls, "Form") { + swapped = strings.ReplaceAll(cls, "Form", "Page") + } else if strings.Contains(cls, "Page") { + swapped = strings.ReplaceAll(cls, "Page", "Form") + } + if swapped != cls { + if tryMatch(ns, swapped, registered) { + return ns + "$" + swapped, "Form↔Page" + } + // Also try Forms namespace + if registered["Forms$"+swapped] { + return "Forms$" + swapped, "Form↔Page+ns" + } + } + + return "", "" +} + +func splitType(t string) (ns, cls string) { + if idx := strings.IndexByte(t, '$'); idx > 0 { + return t[:idx], t[idx+1:] + } + return "", t +} + +func tryMatch(ns, cls string, registered map[string]bool) bool { + return registered[ns+"$"+cls] +} + +func collectNamespaces(registered map[string]bool) []string { + nsSet := map[string]bool{} + for t := range registered { + if ns, _ := splitType(t); ns != "" { + nsSet[ns] = true + } + } + nsList := make([]string, 0, len(nsSet)) + for ns := range nsSet { + nsList = append(nsList, ns) + } + sort.Strings(nsList) + return nsList +} + +// ── audit-keys: ByIdRef BSON key mismatch detection ── + +// byIdRefEntry describes a single ByIdRef property declaration found in generated code. +type byIdRefEntry struct { + TypeName string // e.g. "Microflows$SequenceFlow" + BSONKey string // key passed to NewByIdRef (e.g. "Origin" or "OriginPointer") +} + +// collectByIdRefKeys scans generated types.go files for NewByIdRef[...]("Key") calls. +func collectByIdRefKeys(genBase string) []byIdRefEntry { + var entries []byIdRefEntry + dirs, _ := os.ReadDir(genBase) + for _, d := range dirs { + if !d.IsDir() { + continue + } + typesFile := filepath.Join(genBase, d.Name(), "types.go") + data, err := os.ReadFile(typesFile) + if err != nil { + continue + } + content := string(data) + // Find each init function and its type name, then find NewByIdRef calls inside + var currentType string + for _, line := range strings.Split(content, "\n") { + trimmed := strings.TrimSpace(line) + const prefix = `o.SetTypeName("` + if strings.HasPrefix(trimmed, prefix) { + rest := trimmed[len(prefix):] + end := strings.IndexByte(rest, '"') + if end > 0 { + currentType = rest[:end] + } + } + if strings.Contains(trimmed, "property.NewByIdRef[") && currentType != "" { + // Extract the BSON key from: property.NewByIdRef[element.Element]("Key") + // Find the last ("..." pattern which is the constructor argument + const marker = `](` + idx := strings.Index(trimmed, marker) + if idx < 0 { + continue + } + rest := trimmed[idx+len(marker):] + if len(rest) < 3 || rest[0] != '"' { + continue + } + end := strings.IndexByte(rest[1:], '"') + if end < 0 { + continue + } + bsonKey := rest[1 : 1+end] + entries = append(entries, byIdRefEntry{TypeName: currentType, BSONKey: bsonKey}) + } + } + } + return entries +} + +// auditPropertyKeys scans MPR BSON for ByIdRef key mismatches. +// For each registered ByIdRef property, checks if the BSON key exists in actual +// documents. If not, checks if a "Pointer" suffix variant exists. +func auditPropertyKeys(paths []string, refs []byIdRefEntry) { + // Collect BSON keys per $Type from all MPR sources. + typeFields := map[string]map[string]bool{} // $Type -> set of BSON keys + for _, p := range paths { + info, err := os.Stat(p) + if err != nil { + fmt.Fprintf(os.Stderr, "skip %s: %v\n", p, err) + continue + } + if info.IsDir() { + walkDirForKeys(p, typeFields) + } else { + walkSQLiteForKeys(p, typeFields) + } + } + + // Compare + type mismatch struct { + TypeName string + CodegenKey string + BSONKey string + } + var mismatches []mismatch + var ok, missing int + + for _, ref := range refs { + fields, found := typeFields[ref.TypeName] + if !found { + continue // type not in any MPR, skip + } + if fields[ref.BSONKey] { + ok++ + continue + } + // Try Pointer suffix + pointerKey := ref.BSONKey + "Pointer" + if fields[pointerKey] { + mismatches = append(mismatches, mismatch{ref.TypeName, ref.BSONKey, pointerKey}) + } else { + missing++ + } + } + + fmt.Printf("\nByIdRef BSON Key Audit\n") + fmt.Printf(" Checked: %d ByIdRef properties\n", ok+len(mismatches)+missing) + fmt.Printf(" OK: %d\n", ok) + fmt.Printf(" Mismatches: %d\n", len(mismatches)) + fmt.Printf(" No instances: %d\n\n", missing) + + if len(mismatches) == 0 { + fmt.Println("No mismatches found.") + return + } + + fmt.Println("=== MISMATCHES (add to property_key_overrides in supplements.json) ===") + fmt.Println() + for _, m := range mismatches { + _, cls := splitType(m.TypeName) + fmt.Printf(" %-50s codegen=%q bson=%q\n", m.TypeName, m.CodegenKey, m.BSONKey) + // Suggest override entry + fmt.Printf(" \"%s.???\": \"%s\",\n\n", cls, m.BSONKey) + } +} + +func walkDirForKeys(dir string, typeFields map[string]map[string]bool) { + filepath.Walk(dir, func(p string, info os.FileInfo, err error) error { + if err != nil || info.IsDir() || filepath.Ext(p) != ".mxunit" { + return nil + } + data, err := os.ReadFile(p) + if err != nil { + return nil + } + var doc bson.D + if bson.Unmarshal(data, &doc) == nil { + walkDocKeys(doc, typeFields) + } + return nil + }) +} + +func walkSQLiteForKeys(dbPath string, typeFields map[string]map[string]bool) { + db, err := sql.Open("sqlite", dbPath) + if err != nil { + return + } + defer db.Close() + + rows, err := db.Query("SELECT Contents FROM Unit WHERE Contents IS NOT NULL AND LENGTH(Contents) > 0") + if err != nil { + return + } + defer rows.Close() + + for rows.Next() { + var contents []byte + if err := rows.Scan(&contents); err != nil { + continue + } + var doc bson.D + if bson.Unmarshal(contents, &doc) == nil { + walkDocKeys(doc, typeFields) + } + } +} + +func walkDocKeys(doc bson.D, typeFields map[string]map[string]bool) { + var typeName string + for _, elem := range doc { + if elem.Key == "$Type" { + if s, ok := elem.Value.(string); ok { + typeName = s + } + } + } + if typeName != "" { + if typeFields[typeName] == nil { + typeFields[typeName] = map[string]bool{} + } + for _, elem := range doc { + typeFields[typeName][elem.Key] = true + } + } + // Recurse + for _, elem := range doc { + switch v := elem.Value.(type) { + case bson.D: + walkDocKeys(v, typeFields) + case bson.A: + walkArrayKeys(v, typeFields) + } + } +} + +func walkArrayKeys(arr bson.A, typeFields map[string]map[string]bool) { + for _, item := range arr { + switch v := item.(type) { + case bson.D: + walkDocKeys(v, typeFields) + case bson.A: + walkArrayKeys(v, typeFields) + } + } +} + +// --- BSON scanning --- + +func scanDir(dir string, types map[string]int) { + filepath.Walk(dir, func(p string, info os.FileInfo, err error) error { + if err != nil || info.IsDir() || filepath.Ext(p) != ".mxunit" { + return nil + } + data, err := os.ReadFile(p) + if err != nil { + return nil + } + var doc bson.D + if bson.Unmarshal(data, &doc) == nil { + walkDoc(doc, types) + } + return nil + }) +} + +func scanSQLite(dbPath string, types map[string]int) { + db, err := sql.Open("sqlite", dbPath) + if err != nil { + return + } + defer db.Close() + + rows, err := db.Query("SELECT Contents FROM Unit WHERE Contents IS NOT NULL AND LENGTH(Contents) > 0") + if err != nil { + return + } + defer rows.Close() + + for rows.Next() { + var contents []byte + if err := rows.Scan(&contents); err != nil { + continue + } + var doc bson.D + if bson.Unmarshal(contents, &doc) == nil { + walkDoc(doc, types) + } + } +} + +func walkDoc(doc bson.D, types map[string]int) { + for _, elem := range doc { + if elem.Key == "$Type" { + if s, ok := elem.Value.(string); ok { + types[s]++ + } + } + switch v := elem.Value.(type) { + case bson.D: + walkDoc(v, types) + case bson.A: + walkArray(v, types) + } + } +} + +func walkArray(arr bson.A, types map[string]int) { + for _, item := range arr { + switch v := item.(type) { + case bson.D: + walkDoc(v, types) + case bson.A: + walkArray(v, types) + } + } +} diff --git a/cmd/modelsdk-codegen/main.go b/cmd/modelsdk-codegen/main.go new file mode 100644 index 00000000..89433047 --- /dev/null +++ b/cmd/modelsdk-codegen/main.go @@ -0,0 +1,415 @@ +package main + +import ( + "encoding/json" + "flag" + "fmt" + "log" + "os" + "path/filepath" + "strings" + "unicode" + + "github.com/mendixlabs/mxcli/internal/codegen/dtsparser" + "github.com/mendixlabs/mxcli/internal/codegen/emitter" +) + +// All codegen configuration (storage aliases, property key overrides, +// force-concrete types, edge kind overrides, id-ref scope) lives in +// internal/codegen/supplements.json — the single source of truth. +// See loadSupplements() for parsing. + +func main() { + genDir := flag.String("gen-dir", "reference/mendixmodelsdk/src/gen", "TS SDK gen/ directory") + outBase := flag.String("output", "modelsdk/gen", "output base directory") + domains := flag.String("domains", "", "comma-separated domain names (empty = auto-discover all)") + audit := flag.Bool("audit", false, "scan MPR files/dirs (positional args) for unregistered $Type values") + auditKeys := flag.Bool("audit-keys", false, "scan MPR files for ByIdRef BSON key mismatches (Pointer suffix)") + flag.Parse() + + // Audit mode: scan MPR files, compare against registry, report gaps. + if *audit { + args := flag.Args() + if len(args) == 0 { + log.Fatal("audit mode requires at least one MPR file or mprcontents directory as positional argument") + } + registered := collectRegisteredTypes(*outBase) + auditAliases(args, registered) + return + } + + // Audit-keys mode: scan MPR BSON for ByIdRef key mismatches. + if *auditKeys { + args := flag.Args() + if len(args) == 0 { + log.Fatal("audit-keys mode requires at least one MPR file or mprcontents directory as positional argument") + } + byIdRefs := collectByIdRefKeys(*outBase) + auditPropertyKeys(args, byIdRefs) + return + } + + domainList := discoverDomains(*genDir, *domains) + + // Phase 1: Parse all domains to build cross-domain property map. + // Classes like projects.Document define properties (Name, Documentation, + // ExportLevel, Excluded) that are inherited by types in other domains + // (Workflow, Page, Microflow, etc.). Without this map, the inheritance + // walker stops at cross-domain boundaries and those setters are missing. + crossDomainProps := buildCrossDomainProps(*genDir, domainList) + fmt.Printf("Cross-domain base classes: %d\n", len(crossDomainProps)) + + // Load all codegen configuration from supplements.json. + suppl := loadSupplements() + fmt.Printf("Config: %d aliases, %d prop-key overrides, %d force-concrete, %d edge-kinds, %d id-ref-scope, %d extra props, %d extra type groups\n", + len(suppl.StorageAliases), len(suppl.PropertyKeyOverrides), + len(suppl.forceConcreteSet), len(suppl.EdgeKindOverrides), + len(suppl.IdRefScope), len(suppl.parsedExtraProps), len(suppl.parsedExtraTypes)) + + // Phase 2: Generate each domain with cross-domain inheritance resolved. + for _, domain := range domainList { + jsPath := filepath.Join(*genDir, domain+".js") + if _, err := os.Stat(jsPath); err != nil { + log.Fatalf("js file not found: %s", jsPath) + } + meta, err := dtsparser.ParseJsFile(jsPath) + if err != nil { + log.Fatalf("parse %s: %v", jsPath, err) + } + + // Apply storage name aliases from supplements.json. + aliases := map[string]string{} + for jsName, bsonName := range suppl.StorageAliases { + for _, cls := range meta.Classes { + if cls.StructureTypeName == jsName { + aliases[jsName] = bsonName + fmt.Printf(" alias: %s → %s\n", jsName, bsonName) + break + } + } + } + if len(aliases) > 0 { + meta.StorageAliases = aliases + } + + // Force concrete: some classes the parser marks as abstract (no static + // createIn method) but which appear as concrete $Type values in BSON. + for i := range meta.Classes { + if suppl.forceConcreteSet[meta.Classes[i].StructureTypeName] { + meta.Classes[i].IsAbstract = false + fmt.Printf(" force-concrete: %s\n", meta.Classes[i].StructureTypeName) + } + } + + // Inject supplemental extra_properties into existing classes. + for i := range meta.Classes { + cls := &meta.Classes[i] + if extras, ok := suppl.parsedExtraProps[cls.Name]; ok { + for _, ep := range extras { + cls.Properties = append(cls.Properties, supplementPropToJsProp(ep)) + } + fmt.Printf(" +%d extra props on %s\n", len(extras), cls.Name) + } + } + + // Inject supplemental extra_types as new classes. + if extraTypes, ok := suppl.parsedExtraTypes[domain]; ok { + for _, et := range extraTypes { + cls := supplementTypeToJsClass(et) + meta.Classes = append(meta.Classes, cls) + fmt.Printf(" +extra type: %s (%s)\n", cls.Name, cls.StructureTypeName) + } + } + + // Apply property-level BSON key overrides. + meta.PropertyKeyOverrides = suppl.PropertyKeyOverrides + meta.EdgeKindOverrides = suppl.EdgeKindOverrides + meta.IdRefScope = suppl.IdRefScope + meta.CrossDomainProps = crossDomainProps + + outDir := filepath.Join(*outBase, domain) + if err := emitter.Generate(meta, outDir); err != nil { + log.Fatalf("generate %s: %v", domain, err) + } + fmt.Printf("Generated %s: %d classes, %d enums\n", domain, len(meta.Classes), len(meta.Enums)) + } +} + +// ──────────────────────────────────────────────────────────────── +// Supplements: types/properties/aliases not in TypeScript SDK +// ──────────────────────────────────────────────────────────────── + +type supplements struct { + StorageAliases map[string]string `json:"storage_aliases"` + PropertyKeyOverrides map[string]string `json:"property_key_overrides"` + ForceConcreteTypes []string `json:"force_concrete_types"` + EdgeKindOverrides map[string]string `json:"edge_kind_overrides"` + IdRefScope map[string]string `json:"id_ref_scope"` + ExtraProperties map[string]json.RawMessage `json:"extra_properties"` + ExtraTypes map[string]json.RawMessage `json:"extra_types"` + + // Derived after loading. + forceConcreteSet map[string]bool // built from ForceConcreteTypes slice + parsedExtraProps map[string][]supplementProp + parsedExtraTypes map[string][]supplementTypeDef +} + +type supplementProp struct { + Name string `json:"name"` + Kind string `json:"kind"` // Primitive, ByNameRef, Part, PartList + PrimitiveType string `json:"primitive_type"` // String, Boolean, Integer, etc. + Target string `json:"target"` // for ByNameRef +} + +type supplementTypeDef struct { + Name string `json:"name"` + BSONType string `json:"bson_type"` + Properties []supplementProp `json:"properties"` +} + +func loadSupplements() supplements { + data, err := os.ReadFile("internal/codegen/supplements.json") + if err != nil { + fmt.Printf("No supplements.json found, skipping\n") + return supplements{ + parsedExtraProps: map[string][]supplementProp{}, + parsedExtraTypes: map[string][]supplementTypeDef{}, + } + } + var s supplements + if err := json.Unmarshal(data, &s); err != nil { + log.Fatalf("parse supplements.json: %v", err) + } + delete(s.StorageAliases, "_doc") + delete(s.PropertyKeyOverrides, "_doc") + delete(s.EdgeKindOverrides, "_doc") + delete(s.IdRefScope, "_doc") + + // Build force-concrete lookup set. + s.forceConcreteSet = map[string]bool{} + for _, t := range s.ForceConcreteTypes { + s.forceConcreteSet[t] = true + } + + // Parse extra_properties, skipping _doc string entries. + s.parsedExtraProps = map[string][]supplementProp{} + for key, raw := range s.ExtraProperties { + if key == "_doc" { + continue + } + var props []supplementProp + if err := json.Unmarshal(raw, &props); err != nil { + log.Fatalf("parse extra_properties[%s]: %v", key, err) + } + s.parsedExtraProps[key] = props + } + + // Parse extra_types, skipping _doc string entries. + s.parsedExtraTypes = map[string][]supplementTypeDef{} + for key, raw := range s.ExtraTypes { + if key == "_doc" { + continue + } + var types []supplementTypeDef + if err := json.Unmarshal(raw, &types); err != nil { + log.Fatalf("parse extra_types[%s]: %v", key, err) + } + s.parsedExtraTypes[key] = types + } + + return s +} + +func supplementPropToJsProp(sp supplementProp) dtsparser.JsProp { + p := dtsparser.JsProp{Name: sp.Name} + switch sp.Kind { + case "Primitive": + p.Kind = dtsparser.PKPrimitive + p.PrimitiveType = dtsparser.PrimitiveType(sp.PrimitiveType) + case "ByNameRef": + p.Kind = dtsparser.PKByNameRef + p.TargetType = sp.Target + case "Part": + p.Kind = dtsparser.PKPart + case "PartList": + p.Kind = dtsparser.PKPartList + case "Enum": + p.Kind = dtsparser.PKEnum + p.TargetType = sp.Target + default: + p.Kind = dtsparser.PKPrimitive + p.PrimitiveType = dtsparser.PTString + } + return p +} + +func supplementTypeToJsClass(et supplementTypeDef) dtsparser.JsClass { + cls := dtsparser.JsClass{ + Name: et.Name, + StructureTypeName: et.BSONType, + } + for _, sp := range et.Properties { + cls.Properties = append(cls.Properties, supplementPropToJsProp(sp)) + } + return cls +} + +// pascalCase converts a camelCase string to PascalCase. +func pascalCase(s string) string { + if s == "" { + return s + } + r := []rune(s) + r[0] = unicode.ToUpper(r[0]) + return string(r) +} + +// buildCrossDomainProps parses all domains and collects class properties +// (including inherited) that might be needed across domain boundaries. +// For example, projects.Document defines Name — MxSchema extends Document, +// and JsonStructure extends MxSchema. JsonStructure needs Name even though +// it crosses two domain boundaries. +func buildCrossDomainProps(genDir string, domainList []string) map[string][]dtsparser.JsProp { + // Step 1: Collect all classes with their own properties and base class. + type classInfo struct { + baseName string + ownProps []dtsparser.JsProp + } + allClasses := map[string]*classInfo{} + for _, domain := range domainList { + jsPath := filepath.Join(genDir, domain+".js") + meta, err := dtsparser.ParseJsFile(jsPath) + if err != nil { + continue + } + for _, cls := range meta.Classes { + base := cls.BaseClass + // Strip cross-domain prefix: "projects_1.projects.Document" → "Document" + if idx := strings.LastIndex(base, "."); idx >= 0 { + base = base[idx+1:] + } + // Stop at SDK base types + if strings.HasPrefix(cls.BaseClass, "internal.") { + base = "" + } + allClasses[cls.Name] = &classInfo{ + baseName: base, + ownProps: cls.Properties, + } + } + } + + // Step 2: For each class, walk up the inheritance chain collecting ALL + // properties (own + inherited). Cache results for efficiency. + resolved := map[string][]dtsparser.JsProp{} + var resolve func(name string) []dtsparser.JsProp + resolve = func(name string) []dtsparser.JsProp { + if cached, ok := resolved[name]; ok { + return cached + } + ci, ok := allClasses[name] + if !ok { + return nil + } + // Collect inherited props first (root-first order). + var all []dtsparser.JsProp + seen := map[string]bool{} + if ci.baseName != "" && ci.baseName != name { + for _, p := range resolve(ci.baseName) { + if !seen[p.Name] { + seen[p.Name] = true + all = append(all, p) + } + } + } + for _, p := range ci.ownProps { + if !seen[p.Name] { + seen[p.Name] = true + all = append(all, p) + } + } + resolved[name] = all + return all + } + + result := map[string][]dtsparser.JsProp{} + for name := range allClasses { + props := resolve(name) + if len(props) > 0 { + result[name] = props + } + } + return result +} + +// collectRegisteredTypes scans generated types.go files for all registered $Type names. +func collectRegisteredTypes(genBase string) map[string]bool { + types := map[string]bool{} + entries, err := os.ReadDir(genBase) + if err != nil { + log.Fatalf("read %s: %v", genBase, err) + } + for _, e := range entries { + if !e.IsDir() { + continue + } + typesFile := filepath.Join(genBase, e.Name(), "types.go") + data, err := os.ReadFile(typesFile) + if err != nil { + continue + } + // Extract: codec.DefaultRegistry.Register("Foo$Bar", ...) + content := string(data) + for { + idx := strings.Index(content, `codec.DefaultRegistry.Register("`) + if idx < 0 { + break + } + content = content[idx+len(`codec.DefaultRegistry.Register("`):] + end := strings.IndexByte(content, '"') + if end < 0 { + break + } + types[content[:end]] = true + content = content[end:] + } + } + return types +} + +// discoverDomains returns the list of domains to generate. +// If explicit is non-empty, splits on comma. Otherwise auto-discovers +// from .js files in the gen directory. +func discoverDomains(genDir, explicit string) []string { + if explicit != "" { + var result []string + for _, d := range strings.Split(explicit, ",") { + d = strings.TrimSpace(d) + if d != "" { + result = append(result, d) + } + } + return result + } + + entries, err := os.ReadDir(genDir) + if err != nil { + log.Fatalf("auto-discover: read %s: %v", genDir, err) + } + var result []string + for _, e := range entries { + name := e.Name() + if strings.HasSuffix(name, ".js") && !strings.HasSuffix(name, ".d.ts") { + domain := strings.TrimSuffix(name, ".js") + // Skip internal/base modules + if domain == "all-model-classes" || domain == "base-model" { + continue + } + result = append(result, domain) + } + } + if len(result) == 0 { + log.Fatalf("auto-discover: no .js files found in %s", genDir) + } + return result +} diff --git a/internal/codegen/dtsparser/jsparser.go b/internal/codegen/dtsparser/jsparser.go new file mode 100644 index 00000000..2fbe5f10 --- /dev/null +++ b/internal/codegen/dtsparser/jsparser.go @@ -0,0 +1,755 @@ +// Package dtsparser extracts Mendix metamodel metadata from the official +// TypeScript Model SDK's generated .d.ts and .js files. +package dtsparser + +import ( + "fmt" + "os" + "path/filepath" + "regexp" + "strings" +) + +// ──────────────────────────────────────────────────────────────── +// Core types +// ──────────────────────────────────────────────────────────────── + +// PropKind classifies how a property relates to its owning element. +type PropKind string + +const ( + PKPrimitive PropKind = "Primitive" + PKPrimitiveList PropKind = "PrimitiveList" + PKEnum PropKind = "Enum" + PKEnumList PropKind = "EnumList" + PKPart PropKind = "Part" + PKPartList PropKind = "PartList" + PKByNameRef PropKind = "ByNameRef" + PKByNameRefList PropKind = "ByNameRefList" + PKByIdRef PropKind = "ByIdRef" + PKStructuralChild PropKind = "StructuralChild" + PKStructuralChildList PropKind = "StructuralChildList" + PKUnknown PropKind = "Unknown" +) + +// PrimitiveType is the specific primitive subtype. +type PrimitiveType string + +const ( + PTString PrimitiveType = "String" + PTBoolean PrimitiveType = "Boolean" + PTInteger PrimitiveType = "Integer" + PTDouble PrimitiveType = "Double" + PTGuid PrimitiveType = "Guid" + PTPoint PrimitiveType = "Point" + PTSize PrimitiveType = "Size" + PTColor PrimitiveType = "Color" + PTBlob PrimitiveType = "Blob" +) + +// StructureKind classifies the element's position in the model tree. +type StructureKind string + +const ( + SKElement StructureKind = "Element" + SKModelUnit StructureKind = "ModelUnit" + SKStructuralUnit StructureKind = "StructuralUnit" + SKUnknown StructureKind = "Unknown" +) + +// JsClass represents a fully parsed class from a .js file. +type JsClass struct { + Name string + StructureTypeName string // e.g. "DomainModels$Entity" + BaseClass string // extends ... + StructureKind StructureKind // Element, ModelUnit, StructuralUnit + IsAbstract bool // inferred from create method absence + Properties []JsProp // all declared properties + Defaults []JsDefault // from _initializeDefaultProperties + VersionInfo *JsVersionInfo // parsed versionInfo + Containers []string // containerAs* type names (from .d.ts) + FactoryMethods []JsFactory // createIn* methods (from .d.ts) +} + +// JsProp is a property extracted from the .js constructor. +type JsProp struct { + Name string // serialization key (e.g. "name", "generalization") + Kind PropKind // classified from constructor call + PrimitiveType PrimitiveType // only for PKPrimitive + DefaultValue string // raw default value string + TargetType string // for ByNameRef: "DomainModels$Entity"; for Enum: "ExportLevel" + IsRequired bool // for Part: 5th arg is true + // Version info (property-level) + Introduced string + Deleted string + Public bool + Required bool +} + +// JsDefault represents one default-setting statement from _initializeDefaultProperties. +type JsDefault struct { + Property string // property name + DefaultExpr string // raw expression (e.g. "NoGeneralization.create(this.model)") + IsVersionGated bool // wrapped in if (this.__prop.isAvailable) +} + +// JsVersionInfo holds parsed StructureVersionInfo for a class. +type JsVersionInfo struct { + Introduced string + Deleted string + DeletionMsg string + StructureKind StructureKind // from second param + PropertyInfos map[string]*JsPropVersionInfo +} + +// JsPropVersionInfo holds per-property version metadata. +type JsPropVersionInfo struct { + Introduced string + Deleted string + DeletionMsg string + PublicNow bool + RequiredNow bool +} + +// JsFactory represents a factory method signature. +type JsFactory struct { + Method string // "createIn", "createInEntityUnderAccessRules", etc. + ContainerType string // "Entity", "DomainModel", etc. + PropertyName string // "accessRules", "attributes", etc. (from Under* suffix) + VersionMin string // min version constraint (empty = none) + VersionMax string // max version constraint (empty = none) +} + +// JsEnum represents an enum from .js. +type JsEnum struct { + Name string + Values []JsEnumValue +} + +// JsEnumValue represents a single enum literal. +type JsEnumValue struct { + Name string + Introduced string + Deleted string +} + +// DomainMeta holds the complete extracted metadata for one domain. +type DomainMeta struct { + Namespace string + Classes []JsClass + Enums []JsEnum + Interfaces []JsInterface // from .d.ts + StorageAliases map[string]string // JS $Type → BSON $Type (e.g. "DomainModels$Entity" → "DomainModels$EntityImpl") + + // PropertyKeyOverrides maps "TypeName.propertyName" → BSON key for cases + // where the BSON storage key differs from PascalCase(JS property name). + PropertyKeyOverrides map[string]string + + EdgeKindOverrides map[string]string // TargetType → edge kind hint + IdRefScope map[string]string // "ClassName.propName" → "cross-unit" or "intra-unit" + + // CrossDomainProps maps class names from OTHER domains (e.g. "Document", + // "ModuleDocument") to their properties. Used by the emitter to resolve + // cross-domain inheritance (e.g. Workflow extends projects.Document). + CrossDomainProps map[string][]JsProp +} + +// JsInterface from .d.ts — shows which properties are part of the public API. +type JsInterface struct { + Name string + Extends []string // interface inheritance chain + Properties []string // readonly property names +} + +// ──────────────────────────────────────────────────────────────── +// Regex patterns for .js parsing +// ──────────────────────────────────────────────────────────────── + +var ( + // Class definition: class Foo extends Bar { + rjClass = regexp.MustCompile(`class (\w+) extends (\S+) \{`) + + // Property initialization in constructor: this.__xxx = new internal.PropertyType(...) + // Note: args can contain nested braces like { x: 0, y: 0 }, so we match lazily + // and extract args manually. + rjPropStart = regexp.MustCompile(`this\.__(\w+)\s*=\s*new internal\.(\w+)\(`) + + // structureTypeName: Foo.structureTypeName = "DomainModels$Foo"; + rjStructType = regexp.MustCompile(`(\w+)\.structureTypeName\s*=\s*"([^"]+)"`) + + // versionInfo assignment start: Foo.versionInfo = new exports.StructureVersionInfo({ + rjVersionInfo = regexp.MustCompile(`(\w+)\.versionInfo\s*=\s*new exports\.StructureVersionInfo\(\{`) + + // StructureType parameter: }, internal.StructureType.Element); + rjStructureType = regexp.MustCompile(`internal\.StructureType\.(\w+)\)`) + + // _initializeDefaultProperties method + rjInitDefaults = regexp.MustCompile(`_initializeDefaultProperties\(\)`) + + // Version-gated default: if (this.__propName.isAvailable) { + rjVersionGate = regexp.MustCompile(`if \(this\.__(\w+)\.isAvailable\)`) + + // Simple default assignment: this.propName = value; + rjDefaultAssign = regexp.MustCompile(`^\s+this\.(\w+)\s*=\s*(.+);`) + + // PrimitiveTypeEnum value + rjPrimitiveEnum = regexp.MustCompile(`internal\.PrimitiveTypeEnum\.(\w+)`) + + // Enum default: EnumType.Value + rjEnumDefault = regexp.MustCompile(`(\w+(?:\.\w+)*)\.(\w+)$`) + + // versionInfo property intro/del + rjViIntro = regexp.MustCompile(`introduced:\s*"([^"]+)"`) + rjViDel = regexp.MustCompile(`deleted:\s*"([^"]+)"`) + rjViDelMsg = regexp.MustCompile(`deletionMessage:\s*"([^"]+)"`) + + // versionInfo property public/required currentValue + rjViPublic = regexp.MustCompile(`public:\s*\{\s*currentValue:\s*(true|false)`) + rjViRequired = regexp.MustCompile(`required:\s*\{\s*currentValue:\s*(true|false)`) + + // Namespace extraction: exports.domainmodels = ... + rjNamespace = regexp.MustCompile(`exports\.(\w+)\s*=`) + + // Enum class pattern: class Foo extends internal.AbstractEnum { + // Matches both "internal.AbstractEnum" and "internal_1.internal.AbstractEnum" + rjEnumClass = regexp.MustCompile(`class (\w+) extends (?:internal_\d+\.)?internal\.AbstractEnum`) + + // Enum value: Foo.Bar = new Foo("Bar", { ... }); + rjEnumValue = regexp.MustCompile(`(\w+)\.(\w+)\s*=\s*new \w+\("(\w+)"`) + + // Enum value lifecycle: new internal.LifeCycle("x.y.z", null) + rjLifeCycle = regexp.MustCompile(`new internal(?:_\d+)?\.LifeCycle\("([^"]*)",\s*"?([^")]*)"?\)`) +) + +// ──────────────────────────────────────────────────────────────── +// .js Parser +// ──────────────────────────────────────────────────────────────── + +// ParseJsFile extracts all metadata from a single .js domain file. +func ParseJsFile(path string) (*DomainMeta, error) { + data, err := os.ReadFile(path) + if err != nil { + return nil, fmt.Errorf("read %s: %w", path, err) + } + content := string(data) + lines := strings.Split(content, "\n") + + meta := &DomainMeta{} + + // Extract namespace + if m := rjNamespace.FindStringSubmatch(content); m != nil { + meta.Namespace = m[1] + } + + // Pass 1: structureTypeNames + stnMap := map[string]string{} + for _, m := range rjStructType.FindAllStringSubmatch(content, -1) { + stnMap[m[1]] = m[2] + } + + // Pass 2: Parse classes with constructors and properties + // Use index into slice instead of pointer (slice may grow and reallocate) + classIdxMap := map[string]int{} // name → index in meta.Classes + currentClassIdx := -1 + inConstructor := false + braceDepth := 0 + + for i := 0; i < len(lines); i++ { + line := lines[i] + + // Detect class start + if m := rjClass.FindStringSubmatch(line); m != nil { + cls := JsClass{ + Name: m[1], + BaseClass: m[2], + } + if stn, ok := stnMap[m[1]]; ok { + cls.StructureTypeName = stn + } + meta.Classes = append(meta.Classes, cls) + currentClassIdx = len(meta.Classes) - 1 + classIdxMap[m[1]] = currentClassIdx + continue + } + + // Detect constructor start + if currentClassIdx >= 0 && strings.Contains(line, "constructor(") { + inConstructor = true + // Count braces on the constructor line itself (includes the opening {) + braceDepth = strings.Count(line, "{") - strings.Count(line, "}") + continue + } + + // Parse constructor body + if inConstructor && currentClassIdx >= 0 { + // Track brace depth + braceDepth += strings.Count(line, "{") - strings.Count(line, "}") + if braceDepth <= 0 { + inConstructor = false + continue + } + + if m := rjPropStart.FindStringSubmatchIndex(line); m != nil { + propName := line[m[2]:m[3]] + propType := line[m[4]:m[5]] + // Extract balanced args from after the opening paren + argsStart := m[1] // end of match = right after "(" + args := extractBalancedArgs(line[argsStart:]) + prop := parsePropertyInit(propName, propType, args) + meta.Classes[currentClassIdx].Properties = append(meta.Classes[currentClassIdx].Properties, prop) + } + } + } + + // Rebuild stable classMap after pass 2 (slice is done growing) + classMap := map[string]*JsClass{} + for i := range meta.Classes { + classMap[meta.Classes[i].Name] = &meta.Classes[i] + } + + // Pass 3: Parse _initializeDefaultProperties + // Track which class scope we're in using a simple stack approach + currentClassName := "" + for i := 0; i < len(lines); i++ { + // Track class scope + if m := rjClass.FindStringSubmatch(lines[i]); m != nil { + currentClassName = m[1] + } + + if !rjInitDefaults.MatchString(lines[i]) { + continue + } + + cls := classMap[currentClassName] + if cls == nil { + continue + } + + // Parse the method body — starts at opening brace + depth := strings.Count(lines[i], "{") - strings.Count(lines[i], "}") + versionGatedProp := "" + for j := i + 1; j < len(lines); j++ { + l := lines[j] + depth += strings.Count(l, "{") - strings.Count(l, "}") + + if depth <= 0 { + break + } + + if m := rjVersionGate.FindStringSubmatch(l); m != nil { + versionGatedProp = m[1] + continue + } + + if m := rjDefaultAssign.FindStringSubmatch(l); m != nil { + propName := m[1] + expr := strings.TrimSpace(m[2]) + // Skip "super._initializeDefaultProperties()" + if propName == "super" { + continue + } + gated := versionGatedProp != "" + cls.Defaults = append(cls.Defaults, JsDefault{ + Property: propName, + DefaultExpr: expr, + IsVersionGated: gated, + }) + if gated { + versionGatedProp = "" + } + } + } + } + + // Pass 4: Parse versionInfo + // Pattern: " Entity.versionInfo = new exports.StructureVersionInfo({" + rjVI2 := regexp.MustCompile(`(\w+)\.versionInfo\s*=\s*new exports\.StructureVersionInfo\(`) + for i := 0; i < len(lines); i++ { + m := rjVI2.FindStringSubmatch(lines[i]) + if m == nil { + continue + } + className := m[1] + cls := classMap[className] + if cls == nil { + continue + } + + // Collect the full versionInfo block (find matching close) + block := collectBracedBlock(lines, i) + vi := parseVersionInfoBlock(block) + + // Find structure type from the block itself + if sm := rjStructureType.FindStringSubmatch(block); sm != nil { + switch sm[1] { + case "Element": + vi.StructureKind = SKElement + case "ModelUnit": + vi.StructureKind = SKModelUnit + case "StructuralUnit": + vi.StructureKind = SKStructuralUnit + } + } + + cls.VersionInfo = vi + cls.StructureKind = vi.StructureKind + } + + // Pass 5: Determine abstract status + // Concrete classes have factory methods: "static create(model)" or "static createIn(container)". + // Abstract classes have neither. + reStaticFactory := regexp.MustCompile(`static create(In)?\(`) + for i := range meta.Classes { + cls := &meta.Classes[i] + if cls.StructureTypeName == "" { + continue // no $Type = helper class, not abstract/concrete distinction + } + // Find the class body extent and check for factory methods within it + classPattern := "class " + cls.Name + " extends " + classStart := strings.Index(content, classPattern) + if classStart < 0 { + cls.IsAbstract = true + continue + } + // Find end of class (next class def at same indent, or next ClassName.structureTypeName after the class) + stnPattern := "\n " + cls.Name + ".structureTypeName" + stnIdx := strings.Index(content[classStart:], stnPattern) + var classBody string + if stnIdx > 0 { + classBody = content[classStart : classStart+stnIdx] + } else { + nextClass := strings.Index(content[classStart+len(classPattern):], "\n class ") + if nextClass > 0 { + classBody = content[classStart : classStart+len(classPattern)+nextClass] + } else { + classBody = content[classStart:] + } + } + cls.IsAbstract = !reStaticFactory.MatchString(classBody) + } + + // Pass 6: Parse enum classes and their values + { + var currentEnum *JsEnum + for i := 0; i < len(lines); i++ { + line := lines[i] + if m := rjEnumClass.FindStringSubmatch(line); m != nil { + meta.Enums = append(meta.Enums, JsEnum{Name: m[1]}) + currentEnum = &meta.Enums[len(meta.Enums)-1] + continue + } + // End of enum class scope: next class definition + if currentEnum != nil && rjClass.MatchString(line) { + currentEnum = nil + } + // Enum value: ClassName.Value = new ClassName("Value", ...) + if currentEnum != nil { + if m := rjEnumValue.FindStringSubmatch(line); m != nil { + className := m[1] + valueName := m[3] + if className == currentEnum.Name { + ev := JsEnumValue{Name: valueName} + // Try to parse lifecycle info from the same line + if lc := rjLifeCycle.FindStringSubmatch(line); lc != nil { + ev.Introduced = lc[1] + if lc[2] != "null" && lc[2] != "" { + ev.Deleted = lc[2] + } + } + currentEnum.Values = append(currentEnum.Values, ev) + } + } + } + } + } + + return meta, nil +} + +func parsePropertyInit(name, propType, argsStr string) JsProp { + p := JsProp{Name: name} + + switch propType { + case "PrimitiveProperty": + p.Kind = PKPrimitive + if m := rjPrimitiveEnum.FindStringSubmatch(argsStr); m != nil { + p.PrimitiveType = PrimitiveType(m[1]) + } + p.DefaultValue = extractDefaultArg(argsStr, 3) + + case "PrimitiveListProperty": + p.Kind = PKPrimitiveList + p.DefaultValue = "[]" + + case "EnumProperty": + p.Kind = PKEnum + // args: Class, this, "name", EnumType.Default, EnumType + p.DefaultValue = extractDefaultArg(argsStr, 3) + p.TargetType = extractArgTrimmed(argsStr, 4) + + case "EnumListProperty": + p.Kind = PKEnumList + p.DefaultValue = "[]" + + case "PartProperty": + p.Kind = PKPart + p.DefaultValue = extractDefaultArg(argsStr, 3) + lastArg := extractArgTrimmed(argsStr, 4) + p.IsRequired = lastArg == "true" + + case "PartListProperty": + p.Kind = PKPartList + p.DefaultValue = "[]" + + case "ByNameReferenceProperty": + p.Kind = PKByNameRef + p.TargetType = extractQuotedArg(argsStr, 4) + + case "ByNameReferenceListProperty": + p.Kind = PKByNameRefList + p.TargetType = extractQuotedArg(argsStr, 4) + + case "ByIdReferenceProperty": + p.Kind = PKByIdRef + + case "StructuralChildProperty": + p.Kind = PKStructuralChild + + case "StructuralChildListProperty": + p.Kind = PKStructuralChildList + + case "LocalByNameReferenceProperty": + // Local by-name references (intra-unit) behave like ByNameRef + // for serialization: stored as a string qualified name in BSON. + p.Kind = PKByNameRef + p.TargetType = extractQuotedArg(argsStr, 4) + + default: + p.Kind = PKUnknown + } + + return p +} + +// extractDefaultArg extracts the nth (0-based) comma-separated argument. +func extractDefaultArg(args string, n int) string { + return extractArgTrimmed(args, n) +} + +// extractArgTrimmed splits args by comma (respecting nesting) and returns nth arg trimmed. +func extractArgTrimmed(args string, n int) string { + parts := splitArgs(args) + if n < len(parts) { + return strings.TrimSpace(parts[n]) + } + return "" +} + +// extractQuotedArg extracts a quoted string from nth argument. +func extractQuotedArg(args string, n int) string { + val := extractArgTrimmed(args, n) + val = strings.Trim(val, "\"' ") + return val +} + +// extractBalancedArgs extracts everything up to the matching closing paren. +// Input starts right after the opening "(". +func extractBalancedArgs(s string) string { + depth := 1 + for i, ch := range s { + switch ch { + case '(', '{', '[': + depth++ + case ')', '}', ']': + depth-- + if depth == 0 { + return s[:i] + } + } + } + return s +} + +// splitArgs splits comma-separated args respecting parentheses and brackets. +func splitArgs(s string) []string { + var parts []string + depth := 0 + start := 0 + for i, ch := range s { + switch ch { + case '(', '[', '{': + depth++ + case ')', ']', '}': + depth-- + case ',': + if depth == 0 { + parts = append(parts, s[start:i]) + start = i + 1 + } + } + } + if start < len(s) { + parts = append(parts, s[start:]) + } + return parts +} + +// findEnclosingClass looks backward from line i to find the class name. +func findEnclosingClass(lines []string, i int) string { + for j := i - 1; j >= 0 && j > i-200; j-- { + if m := rjClass.FindStringSubmatch(lines[j]); m != nil { + return m[1] + } + } + return "" +} + +// collectBracedBlock collects text from a starting line until braces balance. +func collectBracedBlock(lines []string, start int) string { + var buf strings.Builder + depth := 0 + for i := start; i < len(lines); i++ { + buf.WriteString(lines[i]) + buf.WriteString("\n") + depth += strings.Count(lines[i], "{") - strings.Count(lines[i], "}") + if depth <= 0 && i > start { + break + } + } + return buf.String() +} + +// parseVersionInfoBlock extracts version metadata from a StructureVersionInfo block. +// The block is a JS object literal like: ClassName.versionInfo = new exports.StructureVersionInfo({ properties: { name: { ... }, ... }, public: { ... } }, internal.StructureType.Element); +func parseVersionInfoBlock(block string) *JsVersionInfo { + vi := &JsVersionInfo{ + PropertyInfos: map[string]*JsPropVersionInfo{}, + } + + lines := strings.Split(block, "\n") + + // State machine: track when we're inside "properties: { ... }" + // and parse each property section individually. + type state int + const ( + stOutside state = iota + stInProperties + stInPropertyBlock + ) + + st := stOutside + propBraceDepth := 0 + currentPropName := "" + var currentPropLines []string + + rePropKey := regexp.MustCompile(`^\s+(\w+):\s*\{`) + + for _, line := range lines { + trimmed := strings.TrimSpace(line) + + switch st { + case stOutside: + if strings.Contains(line, "properties:") && strings.Contains(line, "{") { + st = stInProperties + propBraceDepth = 1 + } + + case stInProperties: + // Are we done with properties block? + propBraceDepth += strings.Count(line, "{") - strings.Count(line, "}") + if propBraceDepth <= 0 { + st = stOutside + continue + } + + // Start of a new property? + if m := rePropKey.FindStringSubmatch(line); m != nil { + name := m[1] + // Skip nested public/required/experimental blocks (they're inside property blocks) + if name == "public" || name == "required" || name == "experimental" || name == "changedIn" { + continue + } + if currentPropName != "" { + // Finalize previous property + vi.PropertyInfos[currentPropName] = parsePropertyVersionLines(currentPropLines) + } + currentPropName = name + currentPropLines = []string{line} + st = stInPropertyBlock + } + + case stInPropertyBlock: + currentPropLines = append(currentPropLines, line) + // Check if this property block closed. We count braces relative to start. + braces := 0 + for _, pl := range currentPropLines { + braces += strings.Count(pl, "{") - strings.Count(pl, "}") + } + if braces <= 0 { + vi.PropertyInfos[currentPropName] = parsePropertyVersionLines(currentPropLines) + currentPropName = "" + currentPropLines = nil + st = stInProperties + } + } + + _ = trimmed + } + + // Handle last property + if currentPropName != "" { + vi.PropertyInfos[currentPropName] = parsePropertyVersionLines(currentPropLines) + } + + return vi +} + +// parsePropertyVersionLines extracts version info from a property's lines. +func parsePropertyVersionLines(lines []string) *JsPropVersionInfo { + pvi := &JsPropVersionInfo{} + joined := strings.Join(lines, "\n") + if m := rjViIntro.FindStringSubmatch(joined); m != nil { + pvi.Introduced = m[1] + } + if m := rjViDel.FindStringSubmatch(joined); m != nil { + pvi.Deleted = m[1] + } + if m := rjViDelMsg.FindStringSubmatch(joined); m != nil { + pvi.DeletionMsg = m[1] + } + if m := rjViPublic.FindStringSubmatch(joined); m != nil { + pvi.PublicNow = m[1] == "true" + } + if m := rjViRequired.FindStringSubmatch(joined); m != nil { + pvi.RequiredNow = m[1] == "true" + } + return pvi +} + +// ──────────────────────────────────────────────────────────────── +// Multi-domain scanning +// ──────────────────────────────────────────────────────────────── + +// ParseAllDomains parses all .js files in the gen/ directory. +func ParseAllDomains(genDir string) ([]*DomainMeta, error) { + entries, err := os.ReadDir(genDir) + if err != nil { + return nil, err + } + var results []*DomainMeta + for _, entry := range entries { + if !strings.HasSuffix(entry.Name(), ".js") || strings.HasSuffix(entry.Name(), ".js.map") { + continue + } + name := strings.TrimSuffix(entry.Name(), ".js") + if name == "base-model" || name == "all-model-classes" { + continue + } + meta, err := ParseJsFile(filepath.Join(genDir, entry.Name())) + if err != nil { + return nil, fmt.Errorf("parse %s: %w", entry.Name(), err) + } + results = append(results, meta) + } + return results, nil +} diff --git a/internal/codegen/dtsparser/jsparser_test.go b/internal/codegen/dtsparser/jsparser_test.go new file mode 100644 index 00000000..c1e31b76 --- /dev/null +++ b/internal/codegen/dtsparser/jsparser_test.go @@ -0,0 +1,452 @@ +package dtsparser + +import ( + "fmt" + "os" + "strings" + "testing" +) + +func TestParseJsDomainModels(t *testing.T) { + jsPath := "../../../reference/mendixmodelsdk/src/gen/domainmodels.js" + if _, err := os.Stat(jsPath); os.IsNotExist(err) { + t.Skip("reference/mendixmodelsdk not available — run: npm install mendixmodelsdk --prefix reference/mendixmodelsdk") + } + meta, err := ParseJsFile(jsPath) + if err != nil { + t.Fatalf("ParseJsFile: %v", err) + } + + t.Logf("Namespace: %s", meta.Namespace) + t.Logf("Total classes: %d", len(meta.Classes)) + + // Build index + idx := map[string]*JsClass{} + for i := range meta.Classes { + idx[meta.Classes[i].Name] = &meta.Classes[i] + } + + // ──────────── Entity ──────────── + t.Run("Entity", func(t *testing.T) { + entity := idx["Entity"] + if entity == nil { + t.Fatal("Entity not found") + } + t.Logf("StructureTypeName: %s", entity.StructureTypeName) + t.Logf("BaseClass: %s", entity.BaseClass) + t.Logf("StructureKind: %s", entity.StructureKind) + t.Logf("IsAbstract: %v", entity.IsAbstract) + t.Logf("Properties (%d):", len(entity.Properties)) + + for _, p := range entity.Properties { + t.Logf(" %-25s Kind=%-20s PrimType=%-8s Default=%-30s Target=%-30s Req=%v", + p.Name, p.Kind, p.PrimitiveType, truncate(p.DefaultValue, 30), p.TargetType, p.IsRequired) + } + + // Verify property kinds + propIdx := map[string]*JsProp{} + for i := range entity.Properties { + propIdx[entity.Properties[i].Name] = &entity.Properties[i] + } + + checks := []struct { + name string + kind PropKind + primType PrimitiveType + target string + }{ + {"name", PKPrimitive, PTString, ""}, + {"dataStorageGuid", PKPrimitive, PTGuid, ""}, + {"location", PKPrimitive, PTPoint, ""}, + {"documentation", PKPrimitive, PTString, ""}, + {"generalization", PKPart, "", ""}, + {"attributes", PKPartList, "", ""}, + {"validationRules", PKPartList, "", ""}, + {"eventHandlers", PKPartList, "", ""}, + {"indexes", PKPartList, "", ""}, + {"accessRules", PKPartList, "", ""}, + {"image", PKByNameRef, "", "Images$Image"}, + {"imageData", PKPrimitive, PTBlob, ""}, + {"isRemote", PKPrimitive, PTBoolean, ""}, + {"source", PKPart, "", ""}, + {"capabilities", PKPart, "", ""}, + {"exportLevel", PKEnum, "", ""}, + } + + for _, c := range checks { + p := propIdx[c.name] + if p == nil { + t.Errorf("property %q not found", c.name) + continue + } + if p.Kind != c.kind { + t.Errorf("%s: Kind = %s, want %s", c.name, p.Kind, c.kind) + } + if c.primType != "" && p.PrimitiveType != c.primType { + t.Errorf("%s: PrimitiveType = %s, want %s", c.name, p.PrimitiveType, c.primType) + } + if c.target != "" && p.TargetType != c.target { + t.Errorf("%s: TargetType = %q, want %q", c.name, p.TargetType, c.target) + } + } + + // Verify StructureTypeName + if entity.StructureTypeName != "DomainModels$Entity" { + t.Errorf("STN = %q, want DomainModels$Entity", entity.StructureTypeName) + } + + // Verify StructureKind + if entity.StructureKind != SKElement { + t.Errorf("StructureKind = %s, want Element", entity.StructureKind) + } + + // Verify not abstract + if entity.IsAbstract { + t.Error("Entity should not be abstract") + } + }) + + // ──────────── Entity defaults ──────────── + t.Run("EntityDefaults", func(t *testing.T) { + entity := idx["Entity"] + if entity == nil { + t.Fatal("Entity not found") + } + t.Logf("Defaults (%d):", len(entity.Defaults)) + for _, d := range entity.Defaults { + t.Logf(" %-25s VersionGated=%v Expr=%s", d.Property, d.IsVersionGated, truncate(d.DefaultExpr, 60)) + } + + // Check some specific defaults + foundGeneralization := false + foundCapabilities := false + foundExportLevel := false + for _, d := range entity.Defaults { + if d.Property == "generalization" { + foundGeneralization = true + if d.IsVersionGated { + t.Error("generalization default should NOT be version-gated") + } + } + if d.Property == "capabilities" { + foundCapabilities = true + if !d.IsVersionGated { + t.Error("capabilities default SHOULD be version-gated") + } + } + if d.Property == "exportLevel" { + foundExportLevel = true + if !d.IsVersionGated { + t.Error("exportLevel default SHOULD be version-gated") + } + } + } + if !foundGeneralization { + t.Error("generalization default not found") + } + if !foundCapabilities { + t.Error("capabilities default not found") + } + if !foundExportLevel { + t.Error("exportLevel default not found") + } + }) + + // ──────────── Entity versionInfo ──────────── + t.Run("EntityVersionInfo", func(t *testing.T) { + entity := idx["Entity"] + if entity == nil || entity.VersionInfo == nil { + t.Fatal("Entity or its VersionInfo not found") + } + vi := entity.VersionInfo + t.Logf("StructureKind: %s", vi.StructureKind) + t.Logf("Property version info (%d):", len(vi.PropertyInfos)) + for name, pvi := range vi.PropertyInfos { + t.Logf(" %-25s Intro=%-8s Del=%-8s Public=%v Req=%v", + name, pvi.Introduced, pvi.Deleted, pvi.PublicNow, pvi.RequiredNow) + } + + // Check specific properties + imgData := vi.PropertyInfos["imageData"] + if imgData == nil { + t.Error("imageData not in versionInfo") + } else if imgData.Introduced != "9.17.0" { + t.Errorf("imageData.Introduced = %q, want 9.17.0", imgData.Introduced) + } + + isRemote := vi.PropertyInfos["isRemote"] + if isRemote == nil { + t.Error("isRemote not in versionInfo") + } else { + if isRemote.Introduced != "7.17.0" { + t.Errorf("isRemote.Introduced = %q, want 7.17.0", isRemote.Introduced) + } + if isRemote.Deleted != "8.10.0" { + t.Errorf("isRemote.Deleted = %q, want 8.10.0", isRemote.Deleted) + } + } + }) + + // ──────────── Abstract classes ──────────── + t.Run("AbstractClasses", func(t *testing.T) { + abstracts := []string{} + for _, c := range meta.Classes { + if c.IsAbstract { + abstracts = append(abstracts, c.Name) + } + } + t.Logf("Abstract classes (%d): %v", len(abstracts), abstracts) + + // Verify some specific ones + expected := map[string]bool{ + "AssociationBase": true, + "GeneralizationBase": true, + "AttributeType": true, + "ValueType": true, + "EntitySource": true, + "MemberRef": true, + } + for name := range expected { + cls := idx[name] + if cls == nil { + t.Errorf("class %s not found", name) + continue + } + if !cls.IsAbstract { + t.Errorf("%s should be abstract", name) + } + } + + // Verify concrete classes are NOT abstract + concrete := []string{"Entity", "Attribute", "Association", "DomainModel"} + for _, name := range concrete { + cls := idx[name] + if cls == nil { + t.Errorf("class %s not found", name) + continue + } + if cls.IsAbstract { + t.Errorf("%s should NOT be abstract", name) + } + } + }) + + // ──────────── DomainModel as ModelUnit ──────────── + t.Run("DomainModelIsModelUnit", func(t *testing.T) { + dm := idx["DomainModel"] + if dm == nil { + t.Fatal("DomainModel not found") + } + if dm.StructureKind != SKModelUnit { + t.Errorf("DomainModel.StructureKind = %s, want ModelUnit", dm.StructureKind) + } + t.Logf("DomainModel: Kind=%s, STN=%s, Props=%d", dm.StructureKind, dm.StructureTypeName, len(dm.Properties)) + for _, p := range dm.Properties { + t.Logf(" %-25s Kind=%-15s", p.Name, p.Kind) + } + }) + + // ──────────── ByNameRef cross-domain ──────────── + t.Run("CrossDomainRefs", func(t *testing.T) { + // AccessRule.moduleRoles should be ByNameRefList targeting Security$ModuleRole + ar := idx["AccessRule"] + if ar == nil { + t.Fatal("AccessRule not found") + } + for _, p := range ar.Properties { + if p.Name == "moduleRoles" { + if p.Kind != PKByNameRefList { + t.Errorf("moduleRoles.Kind = %s, want ByNameRefList", p.Kind) + } + if p.TargetType != "Security$ModuleRole" { + t.Errorf("moduleRoles.TargetType = %q, want Security$ModuleRole", p.TargetType) + } + t.Logf("AccessRule.moduleRoles: Kind=%s Target=%s", p.Kind, p.TargetType) + } + } + }) + + // ──────────── Association ByIdRef ──────────── + t.Run("ByIdRefDetection", func(t *testing.T) { + assoc := idx["Association"] + if assoc == nil { + t.Fatal("Association not found") + } + for _, p := range assoc.Properties { + if p.Name == "child" { + if p.Kind != PKByIdRef { + t.Errorf("child.Kind = %s, want ByIdRef", p.Kind) + } + t.Logf("Association.child: Kind=%s", p.Kind) + } + } + }) + + // ──────────── Part with IsRequired ──────────── + t.Run("PartIsRequired", func(t *testing.T) { + entity := idx["Entity"] + if entity == nil { + t.Fatal("Entity not found") + } + for _, p := range entity.Properties { + if p.Name == "generalization" { + if p.Kind != PKPart { + t.Errorf("generalization.Kind = %s, want Part", p.Kind) + } + if !p.IsRequired { + t.Error("generalization.IsRequired should be true") + } + t.Logf("Entity.generalization: Kind=%s Required=%v", p.Kind, p.IsRequired) + } + } + }) + + // ──────────── Enums ──────────── + t.Run("Enums", func(t *testing.T) { + t.Logf("Enums (%d):", len(meta.Enums)) + for _, e := range meta.Enums { + vals := make([]string, len(e.Values)) + for i, v := range e.Values { + vals[i] = v.Name + } + t.Logf(" %s: %v", e.Name, vals) + } + + if len(meta.Enums) != 12 { + t.Errorf("expected 12 enums, got %d", len(meta.Enums)) + } + + // Check specific enums exist + enumIdx := map[string]*JsEnum{} + for i := range meta.Enums { + enumIdx[meta.Enums[i].Name] = &meta.Enums[i] + } + + am := enumIdx["ActionMoment"] + if am == nil { + t.Fatal("ActionMoment enum not found") + } + if len(am.Values) != 2 { + t.Errorf("ActionMoment: expected 2 values, got %d", len(am.Values)) + } + + an := enumIdx["AssociationNavigability"] + if an == nil { + t.Fatal("AssociationNavigability enum not found") + } + if len(an.Values) != 3 { + t.Errorf("AssociationNavigability: expected 3 values, got %d", len(an.Values)) + } + }) +} + +func TestParseJsAllDomains(t *testing.T) { + genDir := "../../../reference/mendixmodelsdk/src/gen" + if _, err := os.Stat(genDir); os.IsNotExist(err) { + t.Skip("reference/mendixmodelsdk not available") + } + domains, err := ParseAllDomains(genDir) + if err != nil { + t.Fatalf("ParseAllDomains: %v", err) + } + + totalClasses := 0 + totalProps := 0 + kindCounts := map[PropKind]int{} + skCounts := map[StructureKind]int{} + abstractCount := 0 + withVersionInfo := 0 + withDefaults := 0 + crossDomainRefs := 0 + + domainSummary := []string{} + + for _, meta := range domains { + dClasses := len(meta.Classes) + dProps := 0 + dAbstract := 0 + dWithVI := 0 + dWithDef := 0 + dCrossRef := 0 + + for _, c := range meta.Classes { + dProps += len(c.Properties) + for _, p := range c.Properties { + kindCounts[p.Kind]++ + if p.TargetType != "" && strings.Contains(p.TargetType, "$") { + dCrossRef++ + } + } + if c.IsAbstract { + dAbstract++ + } + if c.VersionInfo != nil { + dWithVI++ + skCounts[c.StructureKind]++ + } + if len(c.Defaults) > 0 { + dWithDef++ + } + } + + totalClasses += dClasses + totalProps += dProps + abstractCount += dAbstract + withVersionInfo += dWithVI + withDefaults += dWithDef + crossDomainRefs += dCrossRef + + domainSummary = append(domainSummary, + fmt.Sprintf("%-30s classes=%3d props=%4d abstract=%2d vinfo=%3d defaults=%3d xref=%3d", + meta.Namespace, dClasses, dProps, dAbstract, dWithVI, dWithDef, dCrossRef)) + } + + t.Log("=== Per-Domain Summary ===") + for _, s := range domainSummary { + t.Log(s) + } + + t.Log("\n=== Totals ===") + t.Logf("Domains: %d", len(domains)) + t.Logf("Total classes: %d", totalClasses) + t.Logf("Total properties: %d", totalProps) + t.Logf("Abstract classes: %d", abstractCount) + t.Logf("With VersionInfo: %d", withVersionInfo) + t.Logf("With defaults: %d", withDefaults) + t.Logf("Cross-domain refs: %d", crossDomainRefs) + + t.Log("\n=== Property Kind Distribution ===") + for k, v := range kindCounts { + t.Logf(" %-20s: %4d (%.1f%%)", k, v, float64(v)/float64(totalProps)*100) + } + + t.Log("\n=== Structure Kind Distribution ===") + for k, v := range skCounts { + t.Logf(" %-20s: %d", k, v) + } + + // Unknown should be zero or near zero from .js parsing + unknownPct := float64(kindCounts[PKUnknown]) / float64(totalProps) * 100 + t.Logf("\nUnknown rate: %.1f%% (%d/%d)", unknownPct, kindCounts[PKUnknown], totalProps) + + // Assertions + if len(domains) < 40 { + t.Errorf("expected >= 40 domains, got %d", len(domains)) + } + if totalClasses < 1000 { + t.Errorf("expected >= 1000 classes, got %d", totalClasses) + } + if unknownPct > 2.0 { + t.Errorf("unknown rate %.1f%% too high for .js parsing", unknownPct) + } + if withVersionInfo < totalClasses/2 { + t.Errorf("expected most classes to have versionInfo, got %d/%d", withVersionInfo, totalClasses) + } +} + +func truncate(s string, n int) string { + if len(s) > n { + return s[:n] + "..." + } + return s +} diff --git a/internal/codegen/dtsparser/poc_all_domains_test.go b/internal/codegen/dtsparser/poc_all_domains_test.go new file mode 100644 index 00000000..f561def2 --- /dev/null +++ b/internal/codegen/dtsparser/poc_all_domains_test.go @@ -0,0 +1,107 @@ +package dtsparser + +import ( + "fmt" + "os" + "path/filepath" + "strings" + "testing" +) + +func TestParseAllDomains(t *testing.T) { + genDir := "../../../reference/mendixmodelsdk/src/gen" + if _, err := os.Stat(genDir); os.IsNotExist(err) { + t.Skip("reference/mendixmodelsdk not available") + } + + // Collect all enums across modules + allEnums := collectCrossModuleEnums(genDir) + t.Logf("Cross-module enums collected: %d", len(allEnums)) + + entries, err := os.ReadDir(genDir) + if err != nil { + t.Fatalf("cannot read gen dir: %v", err) + } + + totalClasses := 0 + totalEnums := 0 + totalProps := 0 + totalStructTypeNames := 0 + kindCounts := map[PropertyKind]int{} + domainSummary := []string{} + + for _, entry := range entries { + if !strings.HasSuffix(entry.Name(), ".d.ts") { + continue + } + domain := strings.TrimSuffix(entry.Name(), ".d.ts") + if domain == "base-model" || domain == "all-model-classes" { + continue // meta files, not domain files + } + + dtsData, err := os.ReadFile(filepath.Join(genDir, entry.Name())) + if err != nil { + t.Errorf("cannot read %s: %v", entry.Name(), err) + continue + } + + classes, enums := parseDtsFileWithEnums(string(dtsData), allEnums) + + // Also parse .js for structureTypeNames + jsFile := strings.TrimSuffix(entry.Name(), ".d.ts") + ".js" + jsData, _ := os.ReadFile(filepath.Join(genDir, jsFile)) + stns := parseStructureTypeNames(string(jsData)) + + domainClasses := len(classes) + domainEnums := len(enums) + domainProps := 0 + for _, c := range classes { + domainProps += len(c.Properties) + for _, p := range c.Properties { + kindCounts[p.Kind]++ + } + } + + totalClasses += domainClasses + totalEnums += domainEnums + totalProps += domainProps + totalStructTypeNames += len(stns) + + domainSummary = append(domainSummary, + fmt.Sprintf("%-30s classes=%3d enums=%2d props=%4d $Types=%3d", + domain, domainClasses, domainEnums, domainProps, len(stns))) + } + + t.Log("=== Per-Domain Summary ===") + for _, s := range domainSummary { + t.Log(s) + } + + t.Log("=== Totals ===") + t.Logf("Domains: %d", len(domainSummary)) + t.Logf("Total classes: %d", totalClasses) + t.Logf("Total enums: %d", totalEnums) + t.Logf("Total properties: %d", totalProps) + t.Logf("Total $Type names: %d", totalStructTypeNames) + + t.Log("=== Property Kind Distribution ===") + for k, v := range kindCounts { + t.Logf(" %-10s: %4d (%.1f%%)", k, v, float64(v)/float64(totalProps)*100) + } + + // Classification rate + unknownPct := float64(kindCounts[KindUnknown]) / float64(totalProps) * 100 + classRate := 100 - unknownPct + t.Logf("Classification rate: %.1f%%", classRate) + + // Assertions + if len(domainSummary) < 40 { + t.Errorf("expected at least 40 domains, got %d", len(domainSummary)) + } + if totalClasses < 200 { + t.Errorf("expected at least 200 classes, got %d", totalClasses) + } + if classRate < 80 { + t.Errorf("classification rate %.1f%% too low, expected >= 80%%", classRate) + } +} diff --git a/internal/codegen/dtsparser/poc_test.go b/internal/codegen/dtsparser/poc_test.go new file mode 100644 index 00000000..4d979697 --- /dev/null +++ b/internal/codegen/dtsparser/poc_test.go @@ -0,0 +1,609 @@ +package dtsparser + +import ( + "fmt" + "os" + "regexp" + "strings" + "testing" +) + +// PropertyKind classifies how a property relates to its parent. +type PropertyKind int + +const ( + KindPrimitive PropertyKind = iota // string, bool, number, point, etc. + KindEnum // enumeration value + KindPart // single contained element (1:1) + KindPartList // list of contained elements (1:N) + KindByNameRef // cross-unit reference by qualified name + KindByIdRef // same-unit reference by ID + KindUnknown +) + +func (k PropertyKind) String() string { + switch k { + case KindPrimitive: + return "Primitive" + case KindEnum: + return "Enum" + case KindPart: + return "Part" + case KindPartList: + return "PartList" + case KindByNameRef: + return "ByNameRef" + case KindByIdRef: + return "ByIdRef" + default: + return "Unknown" + } +} + +// DtsClass represents a class extracted from a .d.ts file. +type DtsClass struct { + Name string + Base string // extends ... + Implements string // implements ... + Abstract bool + Properties []DtsProperty + Containers []string // containerAs* types + Factories []DtsFactory + Comments string // JSDoc before class +} + +// DtsProperty represents a property (getter/setter pair) in a .d.ts class. +type DtsProperty struct { + Name string + TypeStr string // raw TS type string + Kind PropertyKind // inferred kind + HasSetter bool + Introduced string // from JSDoc "In version X.Y.Z: introduced" + Deleted string // from JSDoc "In version X.Y.Z: deleted" + Nullable bool // type includes "| null" +} + +// DtsFactory represents a static factory method. +type DtsFactory struct { + MethodName string + ContainerType string + ReturnType string +} + +// DtsEnum represents an enum class. +type DtsEnum struct { + Name string + Values []string +} + +var ( + // Class definition: class Foo extends Bar implements IFoo { + reClass = regexp.MustCompile(`^\s+(abstract )?class (\w+) extends (\S+?)(?:<[^>]+>)? (?:implements (\w+) )?{`) + // Getter: get name(): Type; + reGetter = regexp.MustCompile(`^\s+get (\w+)\(\): (.+);`) + // Setter: set name(newValue: Type); + reSetter = regexp.MustCompile(`^\s+set (\w+)\(`) + // ContainerAs: get containerAsFoo(): Foo; + reContainer = regexp.MustCompile(`^\s+get containerAs(\w+)\(\): `) + // Factory: static createIn(container: Type): ReturnType; + reFactory = regexp.MustCompile(`^\s+static (create\w*)\((?:container: (\w+)|model: \w+)\): (\w+);`) + // Version comment: * In version X.Y.Z: introduced/deleted + reVersion = regexp.MustCompile(`In version ([\d.]+): (\w+)`) + // Enum class: class Foo extends internal.AbstractEnum { + reEnum = regexp.MustCompile(`^\s+class (\w+) extends internal\.AbstractEnum`) + // Enum value: static Foo: EnumType; + reEnumValue = regexp.MustCompile(`^\s+static (\w+): (\w+);`) + // structureTypeName assignment (from .js): Foo.structureTypeName = "DomainModels$Foo"; + reStructType = regexp.MustCompile(`(\w+)\.structureTypeName\s*=\s*"([^"]+)"`) // relaxed: no anchor + // IList type + reIList = regexp.MustCompile(`internal\.IList<(.+)>`) + // QualifiedName companion + reQualifiedName = regexp.MustCompile(`(\w+)QualifiedName`) +) + +// collectCrossModuleEnums scans all .d.ts files in the gen/ directory for enum definitions. +func collectCrossModuleEnums(genDir string) map[string]bool { + enums := map[string]bool{} + entries, err := os.ReadDir(genDir) + if err != nil { + return enums + } + for _, entry := range entries { + if !strings.HasSuffix(entry.Name(), ".d.ts") { + continue + } + data, err := os.ReadFile(genDir + "/" + entry.Name()) + if err != nil { + continue + } + // Extract namespace name from "export declare namespace {" + nsName := "" + reNs := regexp.MustCompile(`export declare namespace (\w+)`) + if m := reNs.FindStringSubmatch(string(data)); m != nil { + nsName = m[1] + } + + for _, line := range strings.Split(string(data), "\n") { + if m := reEnum.FindStringSubmatch(line); m != nil { + enums[m[1]] = true + if nsName != "" { + enums[nsName+"."+m[1]] = true + } + } + } + } + return enums +} + +// inferPropertyKind infers the property kind from the TS type string and context. +func inferPropertyKind(name, typeStr string, hasSetter bool, hasQualifiedNameCompanion bool, knownEnums map[string]bool) PropertyKind { + // Skip derived/accessor properties + if strings.HasPrefix(name, "containerAs") { + return KindUnknown + } + if strings.HasSuffix(name, "QualifiedName") || strings.HasSuffix(name, "QualifiedNames") { + return KindUnknown // companion property, not a real stored property + } + + // IList → PartList (or ByNameRefList if T is an interface from another domain) + if m := reIList.FindStringSubmatch(typeStr); m != nil { + innerType := m[1] + // If inner type starts with I and is from another module (has dot), it's a ByNameRef list + if strings.Contains(innerType, ".I") || (strings.HasPrefix(innerType, "I") && len(innerType) > 1 && innerType[1] >= 'A' && innerType[1] <= 'Z') { + // Check if there's a companion QualifiedNames property + if hasQualifiedNameCompanion { + return KindByNameRef // actually ByNameRefList + } + } + return KindPartList + } + + // Has companion "fooQualifiedName" → ByNameRef + if hasQualifiedNameCompanion { + return KindByNameRef + } + + // Enum types (check if type is a known enum) + cleanType := strings.TrimSuffix(typeStr, " | null") + cleanType = strings.TrimSpace(cleanType) + if knownEnums[cleanType] { + return KindEnum + } + // Enums from other modules: projects.ExportLevel etc. + if dotIdx := strings.LastIndex(cleanType, "."); dotIdx >= 0 { + shortName := cleanType[dotIdx+1:] + if knownEnums[shortName] { + return KindEnum + } + } + + // Primitive types + switch cleanType { + case "string", "boolean", "number": + return KindPrimitive + case "string[]", "boolean[]", "number[]": + return KindPrimitive + } + if strings.HasSuffix(cleanType, ".IPoint") || cleanType == "common.IPoint" { + return KindPrimitive // Point is stored as primitive JSON string + } + if strings.HasSuffix(cleanType, ".ISize") || cleanType == "common.ISize" { + return KindPrimitive + } + + // Remaining: if type is a class/interface (capitalized), it's a Part + if len(cleanType) > 0 && cleanType[0] >= 'A' && cleanType[0] <= 'Z' { + return KindPart + } + if strings.Contains(cleanType, ".") { + return KindPart + } + + return KindUnknown +} + +// parseDtsFile parses a .d.ts file and extracts classes, enums, and their metadata. +func parseDtsFile(content string) (classes []DtsClass, enums []DtsEnum) { + return parseDtsFileWithEnums(content, nil) +} + +// parseDtsFileWithEnums parses a .d.ts file with externally-provided enum knowledge. +func parseDtsFileWithEnums(content string, externalEnums map[string]bool) (classes []DtsClass, enums []DtsEnum) { + lines := strings.Split(content, "\n") + + // First pass: collect enum names (local + external) + knownEnums := map[string]bool{} + for k, v := range externalEnums { + knownEnums[k] = v + } + for _, line := range lines { + if m := reEnum.FindStringSubmatch(line); m != nil { + knownEnums[m[1]] = true + } + } + + // Second pass: parse enums + var currentEnum *DtsEnum + for _, line := range lines { + if m := reEnum.FindStringSubmatch(line); m != nil { + if currentEnum != nil { + enums = append(enums, *currentEnum) + } + currentEnum = &DtsEnum{Name: m[1]} + continue + } + if currentEnum != nil { + if strings.TrimSpace(line) == "}" { + enums = append(enums, *currentEnum) + currentEnum = nil + continue + } + if m := reEnumValue.FindStringSubmatch(line); m != nil { + if m[1] != "qualifiedTsTypeName" { // skip internal field + currentEnum.Values = append(currentEnum.Values, m[1]) + } + } + } + } + + // Third pass: parse classes + var current *DtsClass + var commentBuf strings.Builder + // Track all property names to identify QualifiedName companions + var propNames []string + for _, line := range lines { + // Accumulate comments + trimmed := strings.TrimSpace(line) + if strings.HasPrefix(trimmed, "*") || strings.HasPrefix(trimmed, "/**") || strings.HasPrefix(trimmed, "*/") { + commentBuf.WriteString(line) + commentBuf.WriteString("\n") + continue + } + + if m := reClass.FindStringSubmatch(line); m != nil { + // Save previous class + if current != nil { + // Now infer property kinds with QualifiedName companion awareness + qnSet := map[string]bool{} + for _, p := range current.Properties { + if strings.HasSuffix(p.Name, "QualifiedName") { + base := strings.TrimSuffix(p.Name, "QualifiedName") + qnSet[base] = true + } + if strings.HasSuffix(p.Name, "QualifiedNames") { + base := strings.TrimSuffix(p.Name, "QualifiedNames") + qnSet[base] = true + } + } + for i := range current.Properties { + p := ¤t.Properties[i] + p.Kind = inferPropertyKind(p.Name, p.TypeStr, p.HasSetter, qnSet[p.Name], knownEnums) + } + classes = append(classes, *current) + } + current = &DtsClass{ + Name: m[2], + Base: m[3], + Implements: m[4], + Abstract: m[1] != "", + Comments: commentBuf.String(), + } + commentBuf.Reset() + propNames = nil + continue + } + + if current == nil { + commentBuf.Reset() + continue + } + + // Parse container accessors + if m := reContainer.FindStringSubmatch(line); m != nil { + current.Containers = append(current.Containers, m[1]) + commentBuf.Reset() + continue + } + + // Parse factory methods + if m := reFactory.FindStringSubmatch(line); m != nil { + current.Factories = append(current.Factories, DtsFactory{ + MethodName: m[1], + ContainerType: m[2], + ReturnType: m[3], + }) + commentBuf.Reset() + continue + } + + // Parse setters (mark existing properties as having setters) + if m := reSetter.FindStringSubmatch(line); m != nil { + for i := range current.Properties { + if current.Properties[i].Name == m[1] { + current.Properties[i].HasSetter = true + break + } + } + commentBuf.Reset() + continue + } + + // Parse getters + if m := reGetter.FindStringSubmatch(line); m != nil { + propName := m[1] + propType := m[2] + + // Extract version info from accumulated comments + comment := commentBuf.String() + var introduced, deleted string + for _, vm := range reVersion.FindAllStringSubmatch(comment, -1) { + switch vm[2] { + case "introduced": + introduced = vm[1] + case "deleted": + deleted = vm[1] + } + } + + nullable := strings.Contains(propType, "| null") + + prop := DtsProperty{ + Name: propName, + TypeStr: propType, + Introduced: introduced, + Deleted: deleted, + Nullable: nullable, + } + current.Properties = append(current.Properties, prop) + propNames = append(propNames, propName) + commentBuf.Reset() + continue + } + + // Closing brace + if trimmed == "}" && current != nil { + // could be end of class — but nested braces make this tricky + // We rely on next class/enum/interface definition to finalize + } + + commentBuf.Reset() + } + + // Finalize last class + if current != nil { + qnSet := map[string]bool{} + for _, p := range current.Properties { + if strings.HasSuffix(p.Name, "QualifiedName") { + base := strings.TrimSuffix(p.Name, "QualifiedName") + qnSet[base] = true + } + if strings.HasSuffix(p.Name, "QualifiedNames") { + base := strings.TrimSuffix(p.Name, "QualifiedNames") + qnSet[base] = true + } + } + for i := range current.Properties { + p := ¤t.Properties[i] + p.Kind = inferPropertyKind(p.Name, p.TypeStr, p.HasSetter, qnSet[p.Name], knownEnums) + } + classes = append(classes, *current) + } + + _ = propNames + return +} + +// parseStructureTypeNames extracts structureTypeName assignments from a .js file. +func parseStructureTypeNames(jsContent string) map[string]string { + result := map[string]string{} + for _, m := range reStructType.FindAllStringSubmatch(jsContent, -1) { + result[m[1]] = m[2] + } + return result +} + +func TestParseDomainModelsDts(t *testing.T) { + genDir := "../../../reference/mendixmodelsdk/src/gen" + dtsPath := genDir + "/domainmodels.d.ts" + jsPath := genDir + "/domainmodels.js" + if _, err := os.Stat(dtsPath); os.IsNotExist(err) { + t.Skip("reference/mendixmodelsdk not available") + } + + dtsData, err := os.ReadFile(dtsPath) + if err != nil { + t.Fatalf("cannot read .d.ts: %v", err) + } + jsData, err := os.ReadFile(jsPath) + if err != nil { + t.Fatalf("cannot read .js: %v", err) + } + + // Collect enums from all modules for cross-module enum detection + allEnums := collectCrossModuleEnums("../../../reference/mendixmodelsdk/src/gen") + + classes, enums := parseDtsFileWithEnums(string(dtsData), allEnums) + structTypeNames := parseStructureTypeNames(string(jsData)) + + // ==================== Enum Verification ==================== + t.Run("Enums", func(t *testing.T) { + if len(enums) == 0 { + t.Fatal("expected to find enums") + } + t.Logf("Found %d enums:", len(enums)) + for _, e := range enums { + t.Logf(" %s: %v", e.Name, e.Values) + } + + // Verify specific enum + found := false + for _, e := range enums { + if e.Name == "AssociationType" { + found = true + if len(e.Values) != 2 { + t.Errorf("AssociationType should have 2 values, got %d", len(e.Values)) + } + for _, v := range e.Values { + if v != "Reference" && v != "ReferenceSet" { + t.Errorf("unexpected AssociationType value: %s", v) + } + } + } + } + if !found { + t.Error("AssociationType enum not found") + } + }) + + // ==================== Class Verification ==================== + t.Run("Classes", func(t *testing.T) { + if len(classes) == 0 { + t.Fatal("expected to find classes") + } + t.Logf("Found %d classes", len(classes)) + + // Build class index + classIdx := map[string]*DtsClass{} + for i := range classes { + classIdx[classes[i].Name] = &classes[i] + } + + // Verify Entity class + entity := classIdx["Entity"] + if entity == nil { + t.Fatal("Entity class not found") + } + t.Logf("Entity class: extends=%s, implements=%s, abstract=%v", entity.Base, entity.Implements, entity.Abstract) + t.Logf(" Containers: %v", entity.Containers) + t.Logf(" Factories: %d", len(entity.Factories)) + for _, f := range entity.Factories { + t.Logf(" %s(container: %s): %s", f.MethodName, f.ContainerType, f.ReturnType) + } + + // Verify Entity properties + t.Logf(" Properties (%d):", len(entity.Properties)) + for _, p := range entity.Properties { + t.Logf(" %-30s %-40s Kind=%-10s Setter=%v Intro=%s Del=%s Null=%v", + p.Name, p.TypeStr, p.Kind, p.HasSetter, p.Introduced, p.Deleted, p.Nullable) + } + + // Check specific property kinds + propIdx := map[string]*DtsProperty{} + for i := range entity.Properties { + propIdx[entity.Properties[i].Name] = &entity.Properties[i] + } + + checks := []struct { + name string + kind PropertyKind + }{ + {"name", KindPrimitive}, + {"documentation", KindPrimitive}, + {"location", KindPrimitive}, // common.IPoint → Primitive + {"generalization", KindPart}, // GeneralizationBase → Part + {"attributes", KindPartList}, // IList → PartList + {"validationRules", KindPartList}, // IList → PartList + {"indexes", KindPartList}, // IList → PartList + {"accessRules", KindPartList}, // IList → PartList + {"image", KindByNameRef}, // IImage with imageQualifiedName → ByNameRef + {"exportLevel", KindEnum}, // projects.ExportLevel → Enum (need cross-domain enum detection) + {"source", KindPart}, // EntitySource → Part + {"capabilities", KindPart}, // EntityCapabilities → Part + } + + for _, c := range checks { + p := propIdx[c.name] + if p == nil { + t.Errorf("property %q not found", c.name) + continue + } + if p.Kind != c.kind { + t.Errorf("property %q: got Kind=%s, want %s (type=%s)", c.name, p.Kind, c.kind, p.TypeStr) + } + } + + // Version info checks + imageData := propIdx["imageData"] + if imageData == nil { + t.Error("imageData property not found") + } else { + if imageData.Introduced != "9.17.0" { + t.Errorf("imageData.Introduced = %q, want 9.17.0", imageData.Introduced) + } + } + + isRemote := propIdx["isRemote"] + if isRemote == nil { + t.Error("isRemote property not found") + } else { + if isRemote.Introduced != "7.17.0" { + t.Errorf("isRemote.Introduced = %q, want 7.17.0", isRemote.Introduced) + } + if isRemote.Deleted != "8.10.0" { + t.Errorf("isRemote.Deleted = %q, want 8.10.0", isRemote.Deleted) + } + } + + // Verify abstract class + assocBase := classIdx["AssociationBase"] + if assocBase == nil { + t.Fatal("AssociationBase not found") + } + if !assocBase.Abstract { + t.Error("AssociationBase should be abstract") + } + }) + + // ==================== StructureTypeName Verification ==================== + t.Run("StructureTypeNames", func(t *testing.T) { + if len(structTypeNames) == 0 { + t.Fatal("expected structureTypeName assignments") + } + t.Logf("Found %d structureTypeName assignments", len(structTypeNames)) + + checks := map[string]string{ + "Entity": "DomainModels$Entity", + "Attribute": "DomainModels$Attribute", + "Association": "DomainModels$Association", + "DomainModel": "DomainModels$DomainModel", + "NoGeneralization": "DomainModels$NoGeneralization", + "Generalization": "DomainModels$Generalization", + } + for className, want := range checks { + got := structTypeNames[className] + if got != want { + t.Errorf("%s.structureTypeName = %q, want %q", className, got, want) + } + } + }) + + // ==================== Coverage Summary ==================== + t.Run("CoverageSummary", func(t *testing.T) { + totalProps := 0 + kindCounts := map[PropertyKind]int{} + unknownProps := []string{} + for _, c := range classes { + for _, p := range c.Properties { + totalProps++ + kindCounts[p.Kind]++ + if p.Kind == KindUnknown { + unknownProps = append(unknownProps, fmt.Sprintf("%s.%s (%s)", c.Name, p.Name, p.TypeStr)) + } + } + } + t.Logf("Total properties across %d classes: %d", len(classes), totalProps) + for k, v := range kindCounts { + t.Logf(" %-10s: %d (%.1f%%)", k, v, float64(v)/float64(totalProps)*100) + } + if len(unknownProps) > 0 { + t.Logf("Unknown properties (%d):", len(unknownProps)) + for _, p := range unknownProps { + t.Logf(" %s", p) + } + } + + // Classification rate should be high + unknownPct := float64(kindCounts[KindUnknown]) / float64(totalProps) * 100 + t.Logf("Classification rate: %.1f%%", 100-unknownPct) + }) +} diff --git a/internal/codegen/emitter/emitter.go b/internal/codegen/emitter/emitter.go new file mode 100644 index 00000000..c89f4579 --- /dev/null +++ b/internal/codegen/emitter/emitter.go @@ -0,0 +1,645 @@ +// Package emitter generates Go source files from parsed TS SDK metadata. +package emitter + +import ( + "bytes" + "fmt" + "go/format" + "os" + "path/filepath" + "sort" + "strings" + "text/template" + "unicode" + + "github.com/mendixlabs/mxcli/internal/codegen/dtsparser" +) + +// ──────────────────────────────────────────────────────── +// Template data structs +// ──────────────────────────────────────────────────────── + +// TypeData holds template data for one concrete struct. +type TypeData struct { + Name string + StructureTypeName string + StorageAlias string // BSON $Type if different from StructureTypeName + IsAbstract bool // abstract classes have structs but no factory createIn methods + Fields []FieldData + Refs []RefData // reference properties for refs.go generation +} + +// RefData holds template data for a single reference property in refs.go. +type RefData struct { + Prop string // BSON key + Kind string // "RefByName", "RefByNameList", or "RefById" + Target string // TargetType (empty for ByIdRef) +} + +// FieldData holds template data for a single property field. +type FieldData struct { + PropName string // original JS property name + BSONKey string // PascalCase BSON key (e.g. "Name", "Attributes") + FieldName string // Go unexported struct field name (e.g. "name") + FieldType string // Go type, e.g. "*property.Primitive[string]" + FieldIndex int // zero-based index of this field among all properties (for Bind bit) + GetterName string // Go exported getter method name (e.g. "Name") + GetterCall string // method to call on the property (Get, Items, QualifiedName, etc.) + GetterReturn string // Go return type + SetterName string + SetterArg string + SetterCall string + HasSetter bool + AdderName string + AdderArg string + HasAdder bool + RemoverName string + NeedsInit bool // true for Primitive properties (have Init(bson.Raw)) + IsPartChild bool // true for Part/PartList — needs recursive child decode + IsList bool // true for PartList — decoded via DecodeChildren + IsRef bool // true for ByNameRef — string from BSON + IsRefList bool // true for ByNameRefList — string array from BSON + IsIdRef bool // true for ByIdRef — binary UUID from BSON + TargetType string // ByNameRef target type (e.g. "DomainModels$Entity") + IsEnum bool // true for Enum — string from BSON + IsEnumList bool // true for EnumList — string array from BSON + Constructor string // e.g. "property.NewPrimitive[string](\"name\", property.DecodeString)" +} + +// EnumData holds template data for one enum type. +type EnumData struct { + Name string + Values []EnumValueData +} + +// EnumValueData holds a single enum value. +type EnumValueData struct { + Name string // original value name + GoConst string // e.g. "ExportLevelHidden" + TypeAlias string // e.g. "ExportLevel" +} + +// VersionData holds template data for one class's version info. +type VersionData struct { + StructureTypeName string + Props []VersionPropData +} + +// VersionPropData holds template data for one property's version info. +type VersionPropData struct { + Name string + Introduced string + Deleted string + Required bool + Public bool +} + +// typesFileData is the top-level template data for types.go. +type typesFileData struct { + Package string + Types []TypeData +} + +// versionsFileData is the top-level template data for version.go. +type versionsFileData struct { + Package string + Versions []VersionData +} + +// ──────────────────────────────────────────────────────── +// Generate +// ──────────────────────────────────────────────────────── + +// Generate renders Go source files from the parsed domain metadata. +// It writes types.go, enums.go, version.go, and refs.go into outDir. +// The caller (cmd/modelsdk-codegen) is responsible for populating +// meta.StorageAliases before calling Generate. +func Generate(meta *dtsparser.DomainMeta, outDir string) error { + if err := os.MkdirAll(outDir, 0o755); err != nil { + return fmt.Errorf("mkdir %s: %w", outDir, err) + } + + pkg := meta.Namespace + if pkg == "" { + pkg = "generated" + } + + // Build inheritance graph: map class name → *JsClass + classMap := map[string]*dtsparser.JsClass{} + for i := range meta.Classes { + classMap[meta.Classes[i].Name] = &meta.Classes[i] + } + // Inject cross-domain base classes so the inheritance walker can + // resolve types like "Document" from projects domain. + if meta.CrossDomainProps != nil { + for name, props := range meta.CrossDomainProps { + if _, exists := classMap[name]; !exists { + classMap[name] = &dtsparser.JsClass{ + Name: name, + Properties: props, + } + } + } + } + + // Build types data — generate ALL classes (both abstract and concrete). + // Abstract classes need structs for their properties; they just won't + // have factory createIn methods. + var types []TypeData + for i := range meta.Classes { + cls := &meta.Classes[i] + if cls.StructureTypeName == "" { + continue + } + // Collect inherited properties by walking up the inheritance chain. + allProps := collectInheritedProps(cls, classMap) + td := buildTypeDataWithProps(cls, allProps) + td.IsAbstract = cls.IsAbstract + // Look up storage alias if available. + if meta.StorageAliases != nil { + if alias, ok := meta.StorageAliases[cls.StructureTypeName]; ok { + td.StorageAlias = alias + } + } + // Apply namespace mapping so generated code uses BSON storage names + // directly (e.g., "Pages$Page" → "Forms$Page"). + td.StructureTypeName = mapToStorageNamespace(td.StructureTypeName) + for fi := range td.Fields { + td.Fields[fi].Constructor = mapConstructorTargetType(td.Fields[fi].Constructor) + // Apply property-level BSON key overrides. + if meta.PropertyKeyOverrides != nil { + key := cls.Name + "." + td.Fields[fi].PropName + override, ok := meta.PropertyKeyOverrides[key] + if !ok { + // Wildcard: "*.propName" matches any class + override, ok = meta.PropertyKeyOverrides["*."+td.Fields[fi].PropName] + } + if ok { + td.Fields[fi].BSONKey = override + td.Fields[fi].Constructor = strings.Replace( + td.Fields[fi].Constructor, + "\""+exportName(td.Fields[fi].PropName)+"\"", + "\""+override+"\"", 1) + } + } + } + types = append(types, td) + } + + // Build reference metadata for refs.go. + for ti := range types { + td := &types[ti] + for _, f := range td.Fields { + switch { + case f.IsRef: + td.Refs = append(td.Refs, RefData{Prop: f.BSONKey, Kind: "RefByName", Target: f.TargetType}) + case f.IsRefList: + td.Refs = append(td.Refs, RefData{Prop: f.BSONKey, Kind: "RefByNameList", Target: f.TargetType}) + case f.IsIdRef: + td.Refs = append(td.Refs, RefData{Prop: f.BSONKey, Kind: "RefById", Target: ""}) + } + } + } + + // Build enums data. + var enums []EnumData + for _, e := range meta.Enums { + goName := exportName(e.Name) + ed := EnumData{Name: goName} + for _, v := range e.Values { + ed.Values = append(ed.Values, EnumValueData{ + Name: v.Name, + GoConst: goName + exportName(v.Name), + TypeAlias: goName, + }) + } + enums = append(enums, ed) + } + + // Build versions data. + var versions []VersionData + for i := range meta.Classes { + cls := &meta.Classes[i] + if cls.VersionInfo == nil || cls.StructureTypeName == "" { + continue + } + if len(cls.VersionInfo.PropertyInfos) == 0 { + continue + } + mappedName := mapToStorageNamespace(cls.StructureTypeName) + vd := VersionData{StructureTypeName: mappedName} + // Sort property names for stable output across runs. + propNames := make([]string, 0, len(cls.VersionInfo.PropertyInfos)) + for name := range cls.VersionInfo.PropertyInfos { + propNames = append(propNames, name) + } + sort.Strings(propNames) + for _, name := range propNames { + pvi := cls.VersionInfo.PropertyInfos[name] + vd.Props = append(vd.Props, VersionPropData{ + Name: name, + Introduced: pvi.Introduced, + Deleted: pvi.Deleted, + Required: pvi.RequiredNow, + Public: pvi.PublicNow, + }) + } + versions = append(versions, vd) + // Emit a duplicate version entry for the storage alias so both names are covered. + if meta.StorageAliases != nil { + if alias, ok := meta.StorageAliases[cls.StructureTypeName]; ok { + aliasVD := VersionData{StructureTypeName: alias, Props: vd.Props} + versions = append(versions, aliasVD) + } + } + } + + // Render types.go + if err := renderFile(filepath.Join(outDir, "types.go"), typesTemplate, + typesFileData{Package: pkg, Types: types}); err != nil { + return fmt.Errorf("types.go: %w", err) + } + + // Render enums.go + if err := renderFile(filepath.Join(outDir, "enums.go"), enumsTemplate, + struct { + Package string + Enums []EnumData + }{Package: pkg, Enums: enums}); err != nil { + return fmt.Errorf("enums.go: %w", err) + } + + // Render version.go + if err := renderFile(filepath.Join(outDir, "version.go"), versionTemplate, + versionsFileData{Package: pkg, Versions: versions}); err != nil { + return fmt.Errorf("version.go: %w", err) + } + + // Render refs.go + if err := renderFile(filepath.Join(outDir, "refs.go"), refsTemplate, + typesFileData{Package: pkg, Types: types}); err != nil { + return fmt.Errorf("refs.go: %w", err) + } + + return nil +} + +// collectInheritedProps walks up the inheritance chain within the same domain +// and collects all properties (inherited first, then own). +func collectInheritedProps(cls *dtsparser.JsClass, classMap map[string]*dtsparser.JsClass) []dtsparser.JsProp { + var chain []*dtsparser.JsClass + chain = append(chain, cls) + + current := cls + visited := map[string]bool{cls.Name: true} + for { + baseName := resolveBaseClassName(current.BaseClass) + if visited[baseName] { + break // cycle detected + } + base, ok := classMap[baseName] + if !ok { + break // base is in a different domain or is internal.Element + } + visited[baseName] = true + chain = append(chain, base) + current = base + } + + // Reverse to get root-first order. + var allProps []dtsparser.JsProp + seen := map[string]bool{} + for i := len(chain) - 1; i >= 0; i-- { + for _, p := range chain[i].Properties { + if seen[p.Name] { + continue // skip duplicates (shouldn't happen normally) + } + seen[p.Name] = true + allProps = append(allProps, p) + } + } + return allProps +} + +// resolveBaseClassName strips module/import prefixes from a base class reference. +// E.g. "projects_1.projects.ModuleDocument" → "ModuleDocument" +// +// "internal.Element" → "" (SDK base types, stop walk) +// "AssociationBase" → "AssociationBase" +func resolveBaseClassName(base string) string { + if base == "" { + return "" + } + // internal.Element, internal.ModelUnit, internal.StructuralUnit are SDK + // base types — not domain classes. Stop inheritance walk here. + if strings.HasPrefix(base, "internal.") { + return "" + } + // Cross-domain references like "projects_1.projects.Document": + // extract the class name (last segment) so the inheritance walker + // can look it up in classMap (populated from CrossDomainProps). + if idx := strings.LastIndex(base, "."); idx >= 0 { + return base[idx+1:] + } + return base +} + +// buildTypeDataWithProps builds TypeData using a provided list of properties +// (which may include inherited ones). +func buildTypeDataWithProps(cls *dtsparser.JsClass, props []dtsparser.JsProp) TypeData { + td := TypeData{ + Name: exportName(cls.Name), + StructureTypeName: cls.StructureTypeName, + } + for i, p := range props { + fd := buildFieldData(&p) + fd.FieldIndex = i + td.Fields = append(td.Fields, fd) + } + return td +} + +// ──────────────────────────────────────────────────────── +// Build helpers +// ──────────────────────────────────────────────────────── + +// goKeywords is the set of Go reserved keywords that cannot be used as +// identifiers. Property names matching these get a "prop" prefix. +var goKeywords = map[string]bool{ + "break": true, "case": true, "chan": true, "const": true, "continue": true, + "default": true, "defer": true, "else": true, "fallthrough": true, + "for": true, "func": true, "go": true, "goto": true, "if": true, + "import": true, "interface": true, "map": true, "package": true, + "range": true, "return": true, "select": true, "struct": true, + "switch": true, "type": true, "var": true, +} + +// reservedFieldNames is the set of field names that would collide with +// embedded element.Base unexported fields if used as-is. +var reservedFieldNames = map[string]bool{ + "id": true, "typeName": true, "container": true, + "unit": true, "raw": true, "dirty": true, "props": true, +} + +func buildFieldData(p *dtsparser.JsProp) FieldData { + fieldName := unexportName(p.Name) + if reservedFieldNames[fieldName] || goKeywords[fieldName] { + fieldName = "prop" + exportName(p.Name) + } + getterBase := exportName(p.Name) + + // BSON keys in Mendix are PascalCase (e.g. "Name", "Documentation"), + // but JS SDK property names are camelCase (e.g. "name", "documentation"). + // The property Name() must match the BSON key for lazy decode to work. + bsonKey := exportName(p.Name) + // Exception: $ID and $Type are special and stay as-is. + if p.Name == "$ID" || p.Name == "$Type" { + bsonKey = p.Name + } + + fd := FieldData{ + PropName: p.Name, + BSONKey: exportName(p.Name), + FieldName: fieldName, + } + + switch p.Kind { + case dtsparser.PKPrimitive: + goType, decodeFunc := primitiveMapping(p.PrimitiveType) + fd.FieldType = "*property.Primitive[" + goType + "]" + fd.GetterName = getterBase + fd.GetterCall = "Get" + fd.GetterReturn = goType + fd.SetterName = "Set" + getterBase + fd.SetterArg = goType + fd.SetterCall = "Set" + fd.HasSetter = true + fd.NeedsInit = true + fd.Constructor = "property.NewPrimitive[" + goType + "](\"" + bsonKey + "\", property." + decodeFunc + ")" + + case dtsparser.PKPart, dtsparser.PKStructuralChild: + fd.FieldType = "*property.Part[element.Element]" + fd.GetterName = getterBase + fd.GetterCall = "Get" + fd.GetterReturn = "element.Element" + fd.SetterName = "Set" + getterBase + fd.SetterArg = "element.Element" + fd.SetterCall = "Set" + fd.HasSetter = true + fd.IsPartChild = true + fd.Constructor = "property.NewPart[element.Element](\"" + bsonKey + "\")" + + case dtsparser.PKPartList, dtsparser.PKStructuralChildList: + fd.FieldType = "*property.PartList[element.Element]" + fd.GetterName = getterBase + "Items" + fd.GetterCall = "Items" + fd.GetterReturn = "[]element.Element" + fd.HasAdder = true + fd.AdderName = "Add" + getterBase + fd.AdderArg = "element.Element" + fd.RemoverName = "Remove" + getterBase + fd.IsPartChild = true + fd.IsList = true + fd.Constructor = "property.NewPartList[element.Element](\"" + bsonKey + "\")" + + case dtsparser.PKByNameRef: + fd.FieldType = "*property.ByNameRef[element.Element]" + fd.GetterName = getterBase + "QualifiedName" + fd.GetterCall = "QualifiedName" + fd.GetterReturn = "string" + fd.SetterName = "Set" + getterBase + "QualifiedName" + fd.SetterArg = "string" + fd.SetterCall = "SetQualifiedName" + fd.HasSetter = true + fd.IsRef = true + targetType := p.TargetType + if targetType == "" { + targetType = "unknown" + } + fd.TargetType = mapToStorageNamespace(targetType) + fd.Constructor = "property.NewByNameRef[element.Element](\"" + bsonKey + "\", \"" + targetType + "\")" + + case dtsparser.PKByNameRefList: + fd.FieldType = "*property.ByNameRefList[element.Element]" + fd.GetterName = getterBase + "QualifiedNames" + fd.GetterCall = "QualifiedNames" + fd.GetterReturn = "[]string" + fd.IsRefList = true + fd.AdderName = "Add" + getterBase + fd.AdderArg = "string" + fd.HasAdder = true + fd.SetterName = "Set" + getterBase + "QualifiedNames" + fd.SetterArg = "[]string" + fd.SetterCall = "SetQualifiedNames" + fd.HasSetter = true + targetType := p.TargetType + if targetType == "" { + targetType = "unknown" + } + fd.TargetType = mapToStorageNamespace(targetType) + fd.Constructor = "property.NewByNameRefList[element.Element](\"" + bsonKey + "\", \"" + targetType + "\")" + + case dtsparser.PKByIdRef: + fd.FieldType = "*property.ByIdRef[element.Element]" + fd.GetterName = getterBase + "RefID" + fd.GetterCall = "RefID" + fd.GetterReturn = "element.ID" + fd.SetterName = "Set" + getterBase + "ID" + fd.SetterArg = "element.ID" + fd.SetterCall = "SetID" + fd.HasSetter = true + fd.IsIdRef = true + fd.Constructor = "property.NewByIdRef[element.Element](\"" + bsonKey + "\")" + + case dtsparser.PKEnum: + fd.FieldType = "*property.Enum[string]" + fd.GetterName = getterBase + fd.GetterCall = "Get" + fd.GetterReturn = "string" + fd.SetterName = "Set" + getterBase + fd.SetterArg = "string" + fd.SetterCall = "Set" + fd.HasSetter = true + fd.IsEnum = true + fd.Constructor = "property.NewEnum[string](\"" + bsonKey + "\")" + + case dtsparser.PKEnumList: + fd.FieldType = "*property.EnumList[string]" + fd.GetterName = getterBase + "Items" + fd.GetterCall = "Items" + fd.GetterReturn = "[]string" + fd.IsEnumList = true + fd.AdderName = "Add" + getterBase + fd.AdderArg = "string" + fd.HasAdder = true + fd.Constructor = "property.NewEnumList[string](\"" + bsonKey + "\")" + + case dtsparser.PKPrimitiveList: + fd.FieldType = "*property.Primitive[string]" + fd.GetterName = getterBase + fd.GetterCall = "Get" + fd.GetterReturn = "string" + fd.NeedsInit = true + fd.Constructor = "property.NewPrimitive[string](\"" + bsonKey + "\", property.DecodeString)" + + default: + // PKUnknown -- fall back to string primitive + fd.FieldType = "*property.Primitive[string]" + fd.GetterName = getterBase + fd.GetterCall = "Get" + fd.GetterReturn = "string" + fd.NeedsInit = true + fd.Constructor = "property.NewPrimitive[string](\"" + bsonKey + "\", property.DecodeString)" + } + + return fd +} + +// primitiveMapping maps a PrimitiveType to (Go type, decode func name). +func primitiveMapping(pt dtsparser.PrimitiveType) (goType, decodeFunc string) { + switch pt { + case dtsparser.PTBoolean: + return "bool", "DecodeBool" + case dtsparser.PTInteger: + return "int32", "DecodeInt32" + case dtsparser.PTDouble: + return "float64", "DecodeFloat64" + default: + // String, Guid, Blob, Point, Size, Color all map to string + return "string", "DecodeString" + } +} + +// ──────────────────────────────────────────────────────── +// Name conversion +// ──────────────────────────────────────────────────────── + +// exportName converts a camelCase JS name to a Go exported PascalCase name. +func exportName(s string) string { + if s == "" { + return s + } + runes := []rune(s) + runes[0] = unicode.ToUpper(runes[0]) + return string(runes) +} + +// unexportName converts a name to an unexported Go identifier by lowercasing +// the first rune. This is used for struct field names to avoid collisions +// with getter methods. +func unexportName(s string) string { + if s == "" { + return s + } + runes := []rune(s) + runes[0] = unicode.ToLower(runes[0]) + return string(runes) +} + +// ──────────────────────────────────────────────────────── +// Template rendering +// ──────────────────────────────────────────────────────── + +func renderFile(path, tmplStr string, data interface{}) error { + tmpl, err := template.New(filepath.Base(path)).Parse(tmplStr) + if err != nil { + return fmt.Errorf("parse template: %w", err) + } + + var buf bytes.Buffer + if err := tmpl.Execute(&buf, data); err != nil { + return fmt.Errorf("execute template: %w", err) + } + + // Skip go/format for large files to avoid OOM in constrained environments. + src := buf.Bytes() + if len(src) < 200_000 { + if formatted, err := format.Source(src); err == nil { + src = formatted + } + } + + return os.WriteFile(path, src, 0o644) +} + +// namespaceMap maps SDK namespace prefixes to their BSON storage namespace. +// The JS SDK uses "Pages" but BSON stores "Forms". By applying this at codegen +// time, generated code registers types under their BSON storage names directly, +// eliminating runtime alias lookups. +var namespaceMap = map[string]string{ + "Pages": "Forms", +} + +// mapToStorageNamespace replaces the namespace prefix in a structure type name +// using namespaceMap. E.g., "Pages$ActionButton" → "Forms$ActionButton". +func mapToStorageNamespace(stn string) string { + if idx := strings.IndexByte(stn, '$'); idx > 0 { + if mapped, ok := namespaceMap[stn[:idx]]; ok { + return mapped + stn[idx:] + } + } + return stn +} + +// mapConstructorTargetType replaces ByNameRef target types inside constructor +// strings. E.g., `..."Pages$Page")` → `..."Forms$Page")`. +func mapConstructorTargetType(ctor string) string { + for from, to := range namespaceMap { + ctor = strings.ReplaceAll(ctor, "\""+from+"$", "\""+to+"$") + } + return ctor +} + +// init validates that templates parse at startup so errors surface early. +func init() { + for name, ts := range map[string]string{ + "types": typesTemplate, + "enums": enumsTemplate, + "version": versionTemplate, + "refs": refsTemplate, + } { + if _, err := template.New(name).Parse(ts); err != nil { + panic(fmt.Sprintf("emitter: template %q parse error: %v", name, err)) + } + } +} diff --git a/internal/codegen/emitter/emitter_test.go b/internal/codegen/emitter/emitter_test.go new file mode 100644 index 00000000..8ef298a4 --- /dev/null +++ b/internal/codegen/emitter/emitter_test.go @@ -0,0 +1,415 @@ +package emitter + +import ( + "go/parser" + "go/token" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/mendixlabs/mxcli/internal/codegen/dtsparser" +) + +const domainmodelsJS = "../../.." + "/reference/mendixmodelsdk/src/gen/domainmodels.js" + +func TestGenerateDomainModels(t *testing.T) { + if _, err := os.Stat(domainmodelsJS); os.IsNotExist(err) { + t.Skip("reference/mendixmodelsdk not available") + } + // Parse the real domainmodels.js file. + meta, err := dtsparser.ParseJsFile(domainmodelsJS) + if err != nil { + t.Fatalf("ParseJsFile: %v", err) + } + + if meta.Namespace == "" { + t.Fatal("expected non-empty namespace") + } + t.Logf("namespace=%s classes=%d enums=%d", meta.Namespace, len(meta.Classes), len(meta.Enums)) + + // Generate into a temp directory. + outDir := t.TempDir() + if err := Generate(meta, outDir); err != nil { + t.Fatalf("Generate: %v", err) + } + + // Verify files exist. + for _, name := range []string{"types.go", "enums.go", "version.go"} { + path := filepath.Join(outDir, name) + info, err := os.Stat(path) + if err != nil { + t.Errorf("%s: not found: %v", name, err) + continue + } + if info.Size() == 0 { + t.Errorf("%s: file is empty", name) + } + } + + // Read types.go for content checks. + typesBytes, err := os.ReadFile(filepath.Join(outDir, "types.go")) + if err != nil { + t.Fatalf("read types.go: %v", err) + } + types := string(typesBytes) + + // Check: Entity struct exists. + if !strings.Contains(types, "type Entity struct") { + t.Error("types.go missing 'type Entity struct'") + } + + // Check: embeds element.Base. + if !strings.Contains(types, "element.Base") { + t.Error("types.go missing 'element.Base' embed") + } + + // Check: Entity has a Name getter. + if !strings.Contains(types, "func (o *Entity) Name()") { + t.Error("types.go missing Entity.Name() getter") + } + + // Check: Entity has a SetName setter. + if !strings.Contains(types, "func (o *Entity) SetName(") { + t.Error("types.go missing Entity.SetName() setter") + } + + // Check: registry init contains the structure type name. + if !strings.Contains(types, `"DomainModels$Entity"`) { + t.Error("types.go missing registry entry for DomainModels$Entity") + } + + // Check: DomainModel struct exists (it's the structural unit). + if !strings.Contains(types, "type DomainModel struct") { + t.Error("types.go missing 'type DomainModel struct'") + } + + // Read enums.go for content checks. + enumsBytes, err := os.ReadFile(filepath.Join(outDir, "enums.go")) + if err != nil { + t.Fatalf("read enums.go: %v", err) + } + enums := string(enumsBytes) + + // The JS parser may not find enums in all .js formats (enum regex + // sensitivity). When enums are found, verify their structure. + if len(meta.Enums) > 0 { + if !strings.Contains(enums, "type ") || !strings.Contains(enums, "= string") { + t.Error("enums.go missing enum type declarations") + } + if !strings.Contains(enums, "const (") { + t.Error("enums.go missing const block") + } + } else { + t.Log("note: JS parser found 0 enums (known parser limitation for this .js format)") + } + + // Read version.go for content checks. + versionBytes, err := os.ReadFile(filepath.Join(outDir, "version.go")) + if err != nil { + t.Fatalf("read version.go: %v", err) + } + ver := string(versionBytes) + + // Check: version file has at least one entry. + if !strings.Contains(ver, "VersionInfos") { + t.Error("version.go missing VersionInfos map") + } + if !strings.Contains(ver, "version.TypeVersionInfo") { + t.Error("version.go missing version.TypeVersionInfo usage") + } + + // Log some output for debugging. + t.Logf("types.go size: %d bytes", len(typesBytes)) + t.Logf("enums.go size: %d bytes", len(enumsBytes)) + t.Logf("version.go size: %d bytes", len(versionBytes)) +} + +func TestGenerateSyntheticMeta(t *testing.T) { + // Test with a small hand-crafted DomainMeta to verify edge cases. + meta := &dtsparser.DomainMeta{ + Namespace: "testpkg", + Classes: []dtsparser.JsClass{ + { + Name: "MyElement", + StructureTypeName: "TestDomain$MyElement", + StructureKind: dtsparser.SKElement, + IsAbstract: false, + Properties: []dtsparser.JsProp{ + {Name: "name", Kind: dtsparser.PKPrimitive, PrimitiveType: dtsparser.PTString}, + {Name: "active", Kind: dtsparser.PKPrimitive, PrimitiveType: dtsparser.PTBoolean}, + {Name: "count", Kind: dtsparser.PKPrimitive, PrimitiveType: dtsparser.PTInteger}, + {Name: "ratio", Kind: dtsparser.PKPrimitive, PrimitiveType: dtsparser.PTDouble}, + {Name: "child", Kind: dtsparser.PKPart}, + {Name: "children", Kind: dtsparser.PKPartList}, + {Name: "target", Kind: dtsparser.PKByNameRef, TargetType: "TestDomain$Target"}, + {Name: "ref", Kind: dtsparser.PKByIdRef}, + {Name: "status", Kind: dtsparser.PKEnum, TargetType: "MyStatus"}, + {Name: "tags", Kind: dtsparser.PKEnumList}, + {Name: "refs", Kind: dtsparser.PKByNameRefList, TargetType: "TestDomain$Ref"}, + }, + }, + { + // Abstract class — struct generated but not registered. + Name: "AbstractBase", + StructureTypeName: "TestDomain$AbstractBase", + IsAbstract: true, + Properties: []dtsparser.JsProp{ + {Name: "baseProp", Kind: dtsparser.PKPrimitive, PrimitiveType: dtsparser.PTString}, + }, + }, + }, + Enums: []dtsparser.JsEnum{ + { + Name: "MyStatus", + Values: []dtsparser.JsEnumValue{ + {Name: "Active"}, + {Name: "Inactive"}, + {Name: "Deleted"}, + }, + }, + }, + } + + outDir := t.TempDir() + if err := Generate(meta, outDir); err != nil { + t.Fatalf("Generate: %v", err) + } + + // Read types.go + typesBytes, err := os.ReadFile(filepath.Join(outDir, "types.go")) + if err != nil { + t.Fatalf("read types.go: %v", err) + } + types := string(typesBytes) + + // Concrete class generated. + if !strings.Contains(types, "type MyElement struct") { + t.Error("missing MyElement struct") + } + + // Abstract class IS generated as a struct (for inherited properties), + // but is NOT registered in the factory registry. + if !strings.Contains(types, "type AbstractBase struct") { + t.Error("AbstractBase (abstract) should be generated as a struct") + } + + // Registry contains concrete type. + if !strings.Contains(types, `"TestDomain$MyElement"`) { + t.Error("missing registry entry for TestDomain$MyElement") + } + + // Registry does NOT contain abstract type. + if strings.Contains(types, `Register("TestDomain$AbstractBase"`) { + t.Error("abstract type should not be registered in the factory") + } + + // Primitive string getter. + if !strings.Contains(types, "func (o *MyElement) Name() string") { + t.Error("missing Name() getter") + } + + // Primitive string setter. + if !strings.Contains(types, "func (o *MyElement) SetName(v string)") { + t.Error("missing SetName() setter") + } + + // Primitive bool getter. + if !strings.Contains(types, "func (o *MyElement) Active() bool") { + t.Error("missing Active() getter") + } + + // Primitive int32 getter. + if !strings.Contains(types, "func (o *MyElement) Count() int32") { + t.Error("missing Count() getter") + } + + // Primitive float64 getter. + if !strings.Contains(types, "func (o *MyElement) Ratio() float64") { + t.Error("missing Ratio() getter") + } + + // Part setter. + if !strings.Contains(types, "func (o *MyElement) SetChild(") { + t.Error("missing SetChild() setter") + } + + // PartList adder. + if !strings.Contains(types, "func (o *MyElement) AddChildren(") { + t.Error("missing AddChildren() adder") + } + + // ByNameRef getter. + if !strings.Contains(types, "func (o *MyElement) TargetQualifiedName() string") { + t.Error("missing TargetQualifiedName() getter") + } + + // ByIdRef getter. + if !strings.Contains(types, "func (o *MyElement) RefRefID() element.ID") { + t.Error("missing RefRefID() getter") + } + + // Enum getter. + if !strings.Contains(types, "func (o *MyElement) Status() string") { + t.Error("missing Status() getter") + } + + // EnumList getter. + if !strings.Contains(types, "func (o *MyElement) TagsItems() []string") { + t.Error("missing TagsItems() getter") + } + + // ByNameRefList getter. + if !strings.Contains(types, "func (o *MyElement) RefsQualifiedNames() []string") { + t.Error("missing RefsQualifiedNames() getter") + } + + // Fields should be unexported. + if !strings.Contains(types, "name ") && !strings.Contains(types, "\tname ") { + t.Error("expected unexported field 'name'") + } + + // Read enums.go + enumsBytes, err := os.ReadFile(filepath.Join(outDir, "enums.go")) + if err != nil { + t.Fatalf("read enums.go: %v", err) + } + enumStr := string(enumsBytes) + + if !strings.Contains(enumStr, "type MyStatus = string") { + t.Error("missing MyStatus type alias") + } + if !strings.Contains(enumStr, `MyStatusActive`) { + t.Error("missing MyStatusActive const") + } + if !strings.Contains(enumStr, `MyStatusInactive`) { + t.Error("missing MyStatusInactive const") + } + if !strings.Contains(enumStr, `MyStatusDeleted`) { + t.Error("missing MyStatusDeleted const") + } + + t.Logf("types.go:\n%s", types) +} + +func TestDisambiguateReservedNames(t *testing.T) { + meta := &dtsparser.DomainMeta{ + Namespace: "testpkg", + Classes: []dtsparser.JsClass{ + { + Name: "Tricky", + StructureTypeName: "TestDomain$Tricky", + IsAbstract: false, + Properties: []dtsparser.JsProp{ + // These JS property names, when used as unexported Go fields, + // would collide with element.Base's unexported fields. + {Name: "id", Kind: dtsparser.PKPrimitive, PrimitiveType: dtsparser.PTString}, + {Name: "typeName", Kind: dtsparser.PKPrimitive, PrimitiveType: dtsparser.PTString}, + {Name: "container", Kind: dtsparser.PKPrimitive, PrimitiveType: dtsparser.PTString}, + }, + }, + }, + } + + outDir := t.TempDir() + if err := Generate(meta, outDir); err != nil { + t.Fatalf("Generate: %v", err) + } + + typesBytes, err := os.ReadFile(filepath.Join(outDir, "types.go")) + if err != nil { + t.Fatalf("read types.go: %v", err) + } + types := string(typesBytes) + + // "id" collides with Base's unexported field -> should become "propId" + if !strings.Contains(types, "propId") { + t.Error("expected propId for disambiguated 'id' property") + } + + // "typeName" collides with Base's unexported field -> "propTypeName" + if !strings.Contains(types, "propTypeName") { + t.Error("expected propTypeName for disambiguated 'typeName' property") + } + + // "container" collides with Base's unexported field -> "propContainer" + if !strings.Contains(types, "propContainer") { + t.Error("expected propContainer for disambiguated 'container' property") + } + + // Getters should still be exported PascalCase names (no collision since + // they don't shadow embedded methods -- embedded methods have pointer receivers). + // ID() would shadow Base.ID() though, so let's verify the getter name. + // Actually, exported getter "Id" won't shadow "ID" -- they're different names. + // The getter for "id" property will be "Id" (exportName("id") = "Id"). + if !strings.Contains(types, "func (o *Tricky) Id()") { + t.Error("expected Id() getter for 'id' property") + } +} + +func TestGeneratedCodeParses(t *testing.T) { + if _, err := os.Stat(domainmodelsJS); os.IsNotExist(err) { + t.Skip("reference/mendixmodelsdk not available") + } + // Generate code from the real domainmodels.js and verify all generated + // files are valid Go source (parseable by go/parser). + meta, err := dtsparser.ParseJsFile(domainmodelsJS) + if err != nil { + t.Fatalf("ParseJsFile: %v", err) + } + + outDir := t.TempDir() + if err := Generate(meta, outDir); err != nil { + t.Fatalf("Generate: %v", err) + } + + fset := token.NewFileSet() + for _, name := range []string{"types.go", "enums.go", "version.go"} { + path := filepath.Join(outDir, name) + _, err := parser.ParseFile(fset, path, nil, parser.AllErrors) + if err != nil { + // Read the file for diagnostics. + data, _ := os.ReadFile(path) + // Show first 40 lines for context. + lines := strings.SplitN(string(data), "\n", 41) + preview := strings.Join(lines, "\n") + t.Errorf("%s: parse error: %v\n--- first lines ---\n%s", name, err, preview) + } + } +} + +func TestExportName(t *testing.T) { + tests := []struct { + input, want string + }{ + {"name", "Name"}, + {"dataStorageGuid", "DataStorageGuid"}, + {"", ""}, + {"Name", "Name"}, + {"a", "A"}, + } + for _, tc := range tests { + got := exportName(tc.input) + if got != tc.want { + t.Errorf("exportName(%q) = %q, want %q", tc.input, got, tc.want) + } + } +} + +func TestUnexportName(t *testing.T) { + tests := []struct { + input, want string + }{ + {"Name", "name"}, + {"name", "name"}, + {"", ""}, + {"A", "a"}, + {"ID", "iD"}, + } + for _, tc := range tests { + got := unexportName(tc.input) + if got != tc.want { + t.Errorf("unexportName(%q) = %q, want %q", tc.input, got, tc.want) + } + } +} diff --git a/internal/codegen/emitter/templates.go b/internal/codegen/emitter/templates.go new file mode 100644 index 00000000..9010d436 --- /dev/null +++ b/internal/codegen/emitter/templates.go @@ -0,0 +1,197 @@ +package emitter + +// Go text/template strings for generating typed element code from DomainMeta. + +const typesTemplate = `// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package {{.Package}} + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) +{{range .Types}}{{$typeName := .Name}} +// ──────────────────────────────────────────────────────── +// {{$typeName}} +// ──────────────────────────────────────────────────────── + +type {{$typeName}} struct { + element.Base{{range .Fields}} + {{.FieldName}} {{.FieldType}}{{end}} +} +{{range .Fields}} +// {{.GetterName}} returns the value of the {{.PropName}} property. +func (o *{{$typeName}}) {{.GetterName}}() {{.GetterReturn}} { + return o.{{.FieldName}}.{{.GetterCall}}() +} +{{if .HasSetter}} +// {{.SetterName}} sets the value of the {{.PropName}} property. +func (o *{{$typeName}}) {{.SetterName}}(v {{.SetterArg}}) { + o.{{.FieldName}}.{{.SetterCall}}(v) +} +{{end}}{{if .HasAdder}} +// {{.AdderName}} appends a child element to the {{.PropName}} list. +func (o *{{$typeName}}) {{.AdderName}}(v {{.AdderArg}}) { + o.{{.FieldName}}.Append(v) +} +{{end}}{{if .IsList}} +// {{.RemoverName}} removes the element at the given index from the {{.PropName}} list. +func (o *{{$typeName}}) {{.RemoverName}}(index int) { + o.{{.FieldName}}.Remove(index) +} +{{end}}{{end}} +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *{{$typeName}}) InitFromRaw(raw bson.Raw) { +{{- range .Fields}}{{if .NeedsInit}} + o.{{.FieldName}}.Init(raw) +{{- end}}{{if .IsPartChild}}{{if .IsList}} + if children, err := codec.DecodeChildren(raw, "{{.BSONKey}}"); err == nil { + for _, child := range children { + o.{{.FieldName}}.AppendFromDecode(child) + } + } +{{- else}} + if child, err := codec.DecodeChild(raw, "{{.BSONKey}}"); err == nil { + o.{{.FieldName}}.SetFromDecode(child) + } +{{- end}}{{end}}{{if .IsRef}} + if val, err := raw.LookupErr("{{.BSONKey}}"); err == nil { + if s, ok := val.StringValueOK(); ok { o.{{.FieldName}}.SetFromDecode(s) } + } +{{- end}}{{if .IsRefList}} + if val, err := raw.LookupErr("{{.BSONKey}}"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.{{.FieldName}}.SetFromDecode(qnames) + } + } +{{- end}}{{if .IsIdRef}} + if val, err := raw.LookupErr("{{.BSONKey}}"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.{{.FieldName}}.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.{{.FieldName}}.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +{{- end}}{{if .IsEnum}} + if val, err := raw.LookupErr("{{.BSONKey}}"); err == nil { + if s, ok := val.StringValueOK(); ok { o.{{.FieldName}}.SetFromDecode(s) } + } +{{- end}}{{if .IsEnumList}} + if val, err := raw.LookupErr("{{.BSONKey}}"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + items := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { items = append(items, s) } + } + o.{{.FieldName}}.SetFromDecode(items) + } + } +{{- end}}{{end}} +} +{{end}} +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── +{{range .Types}}{{if not .IsAbstract}} +// init{{.Name}} creates a {{.Name}} with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func init{{.Name}}() *{{.Name}} { + o := &{{.Name}}{} + o.SetTypeName("{{if .StorageAlias}}{{.StorageAlias}}{{else}}{{.StructureTypeName}}{{end}}"){{range .Fields}} + o.{{.FieldName}} = {{.Constructor}} + o.{{.FieldName}}.Bind(&o.Base, {{.FieldIndex}}){{end}} + o.SetProperties([]element.Property{ {{- range .Fields}}o.{{.FieldName}}, {{end -}} }) + return o +} + +// New{{.Name}} creates a new {{.Name}} for user code. Marked dirty (bit 63 = new element). +func New{{.Name}}() *{{.Name}} { + o := init{{.Name}}() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} +{{end}}{{end}} + +func init() { +{{- range .Types}}{{if not .IsAbstract}} +{{- if .StorageAlias}} + codec.DefaultRegistry.Register("{{.StructureTypeName}}", func() element.Element { + o := init{{.Name}}() + o.SetTypeName("{{.StructureTypeName}}") + return o + }) + codec.DefaultRegistry.Register("{{.StorageAlias}}", func() element.Element { + return init{{.Name}}() + }) +{{- else}} + codec.DefaultRegistry.Register("{{.StructureTypeName}}", func() element.Element { + return init{{.Name}}() + }) +{{- end}}{{end}}{{end}} +} +` + +const enumsTemplate = `// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package {{.Package}} +{{range .Enums}} +// {{.Name}} enumerates the possible values for the {{.Name}} type. +type {{.Name}} = string + +const ({{range .Values}} + {{.GoConst}} {{.TypeAlias}} = "{{.Name}}"{{end}} +) +{{end}} +` + +// versionTemplate emits a map literal per class that has version information. +// Consumers can use version.TypeVersionInfo directly. +const versionTemplate = `// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package {{.Package}} + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ +{{- range .Versions}} + "{{.StructureTypeName}}": { + Properties: map[string]version.PropertyVersionInfo{ + {{- range .Props}} + "{{.Name}}": { + {{- if .Introduced}}Introduced: "{{.Introduced}}", {{end -}} + {{- if .Deleted}}Deleted: "{{.Deleted}}", {{end -}} + {{- if .Required}}Required: true, {{end -}} + {{- if .Public}}Public: true, {{end -}} + }, + {{- end}} + }, + }, +{{- end}} +} +` diff --git a/internal/codegen/emitter/templates_refs.go b/internal/codegen/emitter/templates_refs.go new file mode 100644 index 00000000..435e977b --- /dev/null +++ b/internal/codegen/emitter/templates_refs.go @@ -0,0 +1,31 @@ +package emitter + +const refsTemplate = `// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package {{.Package}} +{{- $hasRefs := false}} +{{- range .Types}}{{if .Refs}}{{$hasRefs = true}}{{end}}{{end}} +{{- if $hasRefs}} + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { +{{- range .Types}}{{if .Refs}} + codec.DefaultRefRegistry.RegisterRefs("{{.StructureTypeName}}", []codec.RefMeta{ + {{- range .Refs}} + {Prop: "{{.Prop}}", Kind: codec.{{.Kind}}, Target: "{{.Target}}"}, + {{- end}} + }) +{{- if .StorageAlias}} + codec.DefaultRefRegistry.RegisterRefs("{{.StorageAlias}}", []codec.RefMeta{ + {{- range .Refs}} + {Prop: "{{.Prop}}", Kind: codec.{{.Kind}}, Target: "{{.Target}}"}, + {{- end}} + }) +{{- end}} +{{- end}}{{end}} +} +{{- end}} +` diff --git a/internal/codegen/supplements.json b/internal/codegen/supplements.json new file mode 100644 index 00000000..3faa86a7 --- /dev/null +++ b/internal/codegen/supplements.json @@ -0,0 +1,263 @@ +{ + "_doc": "Supplements for codegen: types, properties, aliases, and overrides not in TypeScript SDK but needed for BSON fidelity.", + + "storage_aliases": { + "_doc": "SDK structureTypeName → BSON storage $Type. Codegen generates dual registration for each.", + "DomainModels$Entity": "DomainModels$EntityImpl", + "DomainModels$AssociationDeleteBehavior": "DomainModels$DeleteBehavior", + "DomainModels$EventHandler": "DomainModels$EntityEvent", + "DomainModels$Index": "DomainModels$EntityIndex", + "Projects$Module": "Projects$ModuleImpl", + "Pages$PageClientAction": "Forms$FormAction", + "Pages$PageSettings": "Forms$FormSettings", + "Pages$PageParameterMapping": "Forms$FormCallArgument", + "Pages$PageForSpecialization": "Forms$FormForSpecialization", + "Pages$MicroflowClientAction": "Forms$MicroflowAction", + "Pages$NoClientAction": "Forms$NoAction", + "Pages$TabContainer": "Forms$TabControl", + "Pages$DynamicImageViewer": "Forms$ImageViewer", + "Microflows$CreateObjectAction": "Microflows$CreateChangeAction", + "Microflows$ChangeObjectAction": "Microflows$ChangeAction", + "Microflows$MemberChange": "Microflows$ChangeActionItem", + "Microflows$DeleteObjectAction": "Microflows$DeleteAction", + "Microflows$ShowPageAction": "Microflows$ShowFormAction", + "Microflows$AggregateListAction": "Microflows$AggregateAction", + "Microflows$ListOperationAction": "Microflows$ListOperationsAction", + "Microflows$CommitObjectsAction": "Microflows$CommitAction", + "Microflows$RollbackObjectAction": "Microflows$RollbackAction", + "Microflows$ClosePageAction": "Microflows$CloseFormAction", + "ExportMappings$ExportObjectMappingElement": "ExportMappings$ObjectMappingElement", + "ExportMappings$ExportValueMappingElement": "ExportMappings$ValueMappingElement", + "ImportMappings$ImportObjectMappingElement": "ImportMappings$ObjectMappingElement", + "ImportMappings$ImportValueMappingElement": "ImportMappings$ValueMappingElement", + "Security$DemoUser": "Security$DemoUserImpl", + "Projects$OneTimeConversionMarker": "Projects$OneTimeConversion", + "Mappings$MappingMicroflowCall": "Mappings$MappingMicroflowCallImpl", + "WebServices$DataAssociation": "WebServices$DataAssociationImpl", + "WebServices$DataAttribute": "WebServices$DataAttributeImpl", + "WebServices$DataEntity": "WebServices$DataEntityImpl", + "WebServices$PublishedOperation": "WebServices$PublishedOperationImpl", + "WebServices$VersionedService": "WebServices$VersionedServiceImpl", + "WebServices$PublishedWebService": "WebServices$PublishedService", + "Microflows$FileDocumentExport": "ExportXmlAction$FileDocumentExport", + "Microflows$VariableExport": "ExportXmlAction$StringExport", + "XmlSchemas$XmlElement": "XmlSchemas$XmlSchemaContents", + "Microflows$TemplateArgument": "Microflows$TemplateParameter", + "Microflows$MicroflowCallParameterMapping": "Mappings$MicroflowCallParameterMappingImpl", + "DocumentTemplates$DataGridColumn": "Forms$DataGridColumn", + "Settings$Language": "Texts$Language", + "Settings$WebUIProjectSettingsPart": "Forms$WebUIProjectSettingsPart", + "Workflows$Annotation": "Workflows$AnnotationActivity", + "Rest$BasicAuthenticationScheme": "Rest$BasicAuthentication" + }, + + "property_key_overrides": { + "_doc": "ClassName.propertyName → BSON key where it differs from PascalCase(JS name). Wildcard *.prop matches any class.", + "NavigationProfile.menuItemCollection": "Menu", + "NavigationProfile.roleBasedHomePages": "HomeItems", + "Association.parent": "ParentPointer", + "Association.child": "ChildPointer", + "CrossAssociation.parent": "ParentPointer", + "IndexedAttribute.attribute": "AttributePointer", + "PageClientAction.pageSettings": "FormSettings", + "PageSettings.page": "Form", + "PageForSpecialization.page": "Form", + "*.outputVariableName": "VariableName", + "EntityTypeParameterType.typeParameter": "TypeParameterPointer", + "ParameterizedEntityType.typeParameter": "TypeParameterPointer", + "GridControlBar.defaultButton": "DefaultButtonPointer", + "SequenceFlow.origin": "OriginPointer", + "SequenceFlow.destination": "DestinationPointer", + "AnnotationFlow.origin": "OriginPointer", + "AnnotationFlow.destination": "DestinationPointer", + "FlowLine.origin": "OriginPointer", + "FlowLine.destination": "DestinationPointer", + "WidgetProperty.type": "TypePointer", + "WidgetObject.type": "TypePointer", + "WidgetValue.type": "TypePointer", + "ConsensusCompletionCriteria.fallbackOutcome": "FallbackOutcomePointer", + "ThresholdCompletionCriteria.fallbackOutcome": "FallbackOutcomePointer", + "MajorityCompletionCriteria.fallbackOutcome": "FallbackOutcomePointer", + "PublishedODataService2.entityTypes": "Entities", + "EntityType.childMembers": "Members", + "VetoCompletionCriteria.vetoOutcome": "VetoOutcomePointer", + "SnippetCallWidget.snippetCall": "FormCall", + "SnippetCall.snippet": "Form" + }, + + "force_concrete_types": [ + "Microflows$MicroflowParameter", + "Projects$Project", + "Workflows$BoundaryEvent" + ], + + "edge_kind_overrides": { + "_doc": "ByNameRef TargetType → graph edge kind. Empty string = skip. Unlisted defaults to 'references'.", + "DomainModels$Entity": "datasource", + "Microflows$Microflow": "calls", + "Microflows$Nanoflow": "calls", + "Forms$Page": "shows_page", + "Forms$Layout": "uses_layout", + "Forms$Snippet": "calls", + "Workflows$Workflow": "triggers_workflow", + "JavaActions$JavaAction": "calls", + "JavaScriptActions$JavaScriptAction": "calls", + "Constants$Constant": "references", + "Enumerations$Enumeration": "references", + "ExportMappings$ExportMapping": "calls", + "ImportMappings$ImportMapping": "calls", + "NativePages$NativePage": "shows_page", + "NativePages$NativeLayout": "uses_layout", + "Security$UserRole": "grants_access", + "DocumentTemplates$DocumentTemplate": "calls", + "DomainModels$AssociationBase": "references", + "Rest$ConsumedODataService": "references", + "Queues$Queue": "references", + "DomainModels$Attribute": "", + "Microflows$MicroflowParameter": "", + "Microflows$NanoflowParameter": "", + "Microflows$MicroflowCall": "", + "Microflows$NanoflowCall": "", + "Microflows$RuleParameter": "", + "Microflows$Rule": "", + "Forms$LayoutParameter": "", + "Forms$PageParameter": "", + "Forms$SnippetParameter": "", + "JavaActions$JavaActionParameter": "", + "JavaScriptActions$JavaScriptActionParameter":"", + "Security$ModuleRole": "", + "Images$Image": "", + "CustomIcons$CustomIcon": "", + "Menus$MenuDocument": "" + }, + + "id_ref_scope": { + "_doc": "ByIdRef properties that create cross-unit graph edges. Key: ClassName.propertyName. Unlisted defaults to intra-unit.", + "Association.ParentPointer": "cross-unit", + "Association.ChildPointer": "cross-unit", + "CrossAssociation.ParentPointer": "cross-unit" + }, + + "extra_properties": { + "_doc": "Additional properties to inject into existing generated types.", + "DataTransformer": [ + {"name": "sourceJson", "kind": "Primitive", "primitive_type": "String"}, + {"name": "sourceType", "kind": "Primitive", "primitive_type": "String"} + ], + "Step": [ + {"name": "technology", "kind": "Primitive", "primitive_type": "String"}, + {"name": "expression", "kind": "Primitive", "primitive_type": "String"} + ], + "ConsumedODataService": [ + {"name": "serviceUrl", "kind": "Primitive", "primitive_type": "String"}, + {"name": "httpUsername", "kind": "Primitive", "primitive_type": "String"}, + {"name": "httpPassword", "kind": "Primitive", "primitive_type": "String"}, + {"name": "useAuthentication", "kind": "Primitive", "primitive_type": "Boolean"}, + {"name": "clientCertificate", "kind": "Primitive", "primitive_type": "String"}, + {"name": "headers", "kind": "PartList"} + ], + "BoundaryEvent": [ + {"name": "eventType", "kind": "Primitive", "primitive_type": "String"}, + {"name": "delay", "kind": "Primitive", "primitive_type": "String"} + ], + "JumpToActivity": [], + "PublishedODataMember": [], + "PublishedODataEntity": [] + }, + + "extra_types": { + "_doc": "Complete BSON-only type definitions not in TypeScript SDK.", + "rest": [ + { + "name": "RestCallOperation", + "bson_type": "Rest$RestCallOperation", + "properties": [ + {"name": "httpMethod", "kind": "Primitive", "primitive_type": "String"}, + {"name": "url", "kind": "Primitive", "primitive_type": "String"}, + {"name": "timeoutExpression", "kind": "Primitive", "primitive_type": "String"}, + {"name": "proxyType", "kind": "Primitive", "primitive_type": "String"}, + {"name": "parameters", "kind": "PartList"}, + {"name": "queryParameters", "kind": "PartList"}, + {"name": "headers", "kind": "PartList"} + ] + }, + { + "name": "RestCallParameter", + "bson_type": "Rest$RestCallParameter", + "properties": [ + {"name": "name", "kind": "Primitive", "primitive_type": "String"}, + {"name": "type", "kind": "Primitive", "primitive_type": "String"}, + {"name": "value", "kind": "Primitive", "primitive_type": "String"}, + {"name": "testValue", "kind": "Primitive", "primitive_type": "String"} + ] + }, + { + "name": "RestCallHeader", + "bson_type": "Rest$RestCallHeader", + "properties": [ + {"name": "name", "kind": "Primitive", "primitive_type": "String"}, + {"name": "value", "kind": "Primitive", "primitive_type": "String"} + ] + }, + { + "name": "PublishedRestOperation", + "bson_type": "Rest$PublishedRestOperation", + "properties": [ + {"name": "path", "kind": "Primitive", "primitive_type": "String"}, + {"name": "httpMethod", "kind": "Primitive", "primitive_type": "String"}, + {"name": "deprecated", "kind": "Primitive", "primitive_type": "Boolean"}, + {"name": "summary", "kind": "Primitive", "primitive_type": "String"}, + {"name": "description", "kind": "Primitive", "primitive_type": "String"}, + {"name": "microflow", "kind": "ByNameRef", "target": "Microflows$Microflow"}, + {"name": "importMapping", "kind": "ByNameRef", "target": "ImportMappings$ImportMapping"}, + {"name": "exportMapping", "kind": "ByNameRef", "target": "ExportMappings$ExportMapping"}, + {"name": "objectHandlingBackup", "kind": "Primitive", "primitive_type": "String"}, + {"name": "commit", "kind": "Primitive", "primitive_type": "String"} + ] + } + ], + "odatapublish": [ + { + "name": "PublishedODataMember", + "bson_type": "PublishedODataServices$PublishedODataMember", + "properties": [ + {"name": "exposedName", "kind": "Primitive", "primitive_type": "String"}, + {"name": "attribute", "kind": "ByNameRef", "target": "DomainModels$Attribute"}, + {"name": "name", "kind": "Primitive", "primitive_type": "String"}, + {"name": "filterable", "kind": "Primitive", "primitive_type": "Boolean"}, + {"name": "sortable", "kind": "Primitive", "primitive_type": "Boolean"}, + {"name": "isPartOfKey", "kind": "Primitive", "primitive_type": "Boolean"} + ] + }, + { + "name": "ConsumedODataServiceHeader", + "bson_type": "ConsumedODataServices$ConsumedODataServiceHeader", + "properties": [ + {"name": "key", "kind": "Primitive", "primitive_type": "String"}, + {"name": "value", "kind": "Primitive", "primitive_type": "String"} + ] + } + ], + "navigation": [ + { + "name": "NavigationProfileLoginFormSettings", + "bson_type": "Navigation$NavigationProfileLoginFormSettings", + "properties": [ + {"name": "loginPage", "kind": "ByNameRef", "target": "Forms$Page"} + ] + } + ], + "workflows": [ + { + "name": "ExclusiveSplitOutcome", + "bson_type": "Workflows$ExclusiveSplitOutcome", + "properties": [ + {"name": "name", "kind": "Primitive", "primitive_type": "String"}, + {"name": "caption", "kind": "Primitive", "primitive_type": "String"}, + {"name": "value", "kind": "Primitive", "primitive_type": "String"}, + {"name": "flow", "kind": "Part"} + ] + } + ] + } +} diff --git a/modelsdk/codec/bsonbuilder.go b/modelsdk/codec/bsonbuilder.go new file mode 100644 index 00000000..356f864c --- /dev/null +++ b/modelsdk/codec/bsonbuilder.go @@ -0,0 +1,651 @@ +package codec + +import ( + "fmt" + + "go.mongodb.org/mongo-driver/bson" +) + +// --------------------------------------------------------------------------- +// BSONDocBuilder — fluent API for constructing BSON documents without +// exposing bson.D/bson.E/bson.A types to engine/ callers. +// --------------------------------------------------------------------------- + +// BSONDocBuilder builds a BSON document (bson.D) without requiring the +// caller to import go.mongodb.org/mongo-driver/bson. +type BSONDocBuilder struct { + doc bson.D +} + +// NewBSONDoc creates a new empty BSON document builder. +func NewBSONDoc() *BSONDocBuilder { + return &BSONDocBuilder{} +} + +// Set adds or replaces a field with any value. +func (b *BSONDocBuilder) Set(key string, value any) *BSONDocBuilder { + b.doc = append(b.doc, bson.E{Key: key, Value: value}) + return b +} + +// SetIf conditionally adds a field only when the condition is true. +func (b *BSONDocBuilder) SetIf(cond bool, key string, value any) *BSONDocBuilder { + if cond { + b.doc = append(b.doc, bson.E{Key: key, Value: value}) + } + return b +} + +// SetIfNotEmpty adds a string field only when the value is non-empty. +func (b *BSONDocBuilder) SetIfNotEmpty(key, value string) *BSONDocBuilder { + if value != "" { + b.doc = append(b.doc, bson.E{Key: key, Value: value}) + } + return b +} + +// SetChild adds a nested document (another builder) as a field value. +func (b *BSONDocBuilder) SetChild(key string, child *BSONDocBuilder) *BSONDocBuilder { + b.doc = append(b.doc, bson.E{Key: key, Value: child.doc}) + return b +} + +// SetArray adds a versioned array (prefixed with int32(3)) of sub-documents. +func (b *BSONDocBuilder) SetArray(key string, items []*BSONDocBuilder) *BSONDocBuilder { + arr := bson.A{int32(3)} + for _, item := range items { + arr = append(arr, item.doc) + } + b.doc = append(b.doc, bson.E{Key: key, Value: arr}) + return b +} + +// SetStringArray adds an unversioned array of strings. +func (b *BSONDocBuilder) SetStringArray(key string, items []string) *BSONDocBuilder { + arr := bson.A{} + for _, s := range items { + arr = append(arr, s) + } + b.doc = append(b.doc, bson.E{Key: key, Value: arr}) + return b +} + +// Marshal serializes the document to BSON bytes. +func (b *BSONDocBuilder) Marshal() ([]byte, error) { + return bson.Marshal(b.doc) +} + +// --------------------------------------------------------------------------- +// PatchMultiBSONFields — batch set/replace for ALTER operations on []byte. +// --------------------------------------------------------------------------- + +// PatchMultiBSONFields sets or replaces multiple fields in a BSON document. +// This is more efficient than chaining PatchBSONField calls because it +// only unmarshals/marshals once. +func PatchMultiBSONFields(data []byte, fields map[string]any) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + for key, val := range fields { + found := false + for i, e := range doc { + if e.Key == key { + doc[i].Value = val + found = true + break + } + } + if !found { + doc = append(doc, bson.E{Key: key, Value: val}) + } + } + return bson.Marshal(doc) +} + +// --------------------------------------------------------------------------- +// BSON tree-walking helpers — for styling.go and widgets.go recursive +// traversal of widget trees without exposing bson types to engine/. +// --------------------------------------------------------------------------- + +// BSONWalkDocFunc is called for each bson.D node in a tree traversal. +// The function receives the document and can modify it in place. +// Return true to stop traversal (early exit). +type BSONWalkDocFunc func(doc []byte) (replacement []byte, stop bool, err error) + +// WalkBSONTree recursively walks a BSON document tree, calling fn for each +// embedded document node. This is used for widget tree traversal. +// Returns the modified document bytes. +func WalkBSONTree(data []byte, fn func(doc bson.D) (bson.D, bool)) ([]byte, bool, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, false, fmt.Errorf("unmarshal: %w", err) + } + + doc, stopped := walkDoc(doc, fn) + + out, err := bson.Marshal(doc) + if err != nil { + return nil, false, fmt.Errorf("marshal: %w", err) + } + return out, stopped, nil +} + +func walkDoc(doc bson.D, fn func(bson.D) (bson.D, bool)) (bson.D, bool) { + doc, stop := fn(doc) + if stop { + return doc, true + } + for i, e := range doc { + switch v := e.Value.(type) { + case bson.D: + v, stop = walkDoc(v, fn) + doc[i].Value = v + if stop { + return doc, true + } + case bson.A: + v, stop = walkArray(v, fn) + doc[i].Value = v + if stop { + return doc, true + } + } + } + return doc, false +} + +func walkArray(arr bson.A, fn func(bson.D) (bson.D, bool)) (bson.A, bool) { + for i, item := range arr { + if d, ok := item.(bson.D); ok { + d, stop := walkDoc(d, fn) + arr[i] = d + if stop { + return arr, true + } + } + } + return arr, false +} + +// BSONDocGetString returns the string value for a key in a BSON document, +// or empty string if not found. +func BSONDocGetString(doc bson.D, key string) string { + for _, e := range doc { + if e.Key == key { + if s, ok := e.Value.(string); ok { + return s + } + } + } + return "" +} + +// BSONDocGetDoc returns a nested bson.D for a key, or nil if not found. +func BSONDocGetDoc(doc bson.D, key string) bson.D { + for _, e := range doc { + if e.Key == key { + if d, ok := e.Value.(bson.D); ok { + return d + } + } + } + return nil +} + +// NewBSONEmptyDoc returns an empty bson.D for use where callers need +// an empty document value without importing bson. +func NewBSONEmptyDoc() bson.D { + return bson.D{} +} + +// UnmarshalBSONDoc unmarshals raw BSON bytes into a bson.D. +func UnmarshalBSONDoc(data []byte) (bson.D, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, err + } + return doc, nil +} + +// MarshalBSONDoc marshals a bson.D into raw BSON bytes. +func MarshalBSONDoc(doc bson.D) ([]byte, error) { + return bson.Marshal(doc) +} + +// --------------------------------------------------------------------------- +// Styling-specific helpers +// --------------------------------------------------------------------------- + +// ApplyStylingToWidget finds a widget by name in a BSON document tree +// and applies styling changes (Class, Style, or DesignProperties). +// Returns (modifiedDoc, found). +func ApplyStylingToWidget(data []byte, widgetName string, changes map[string]string, clearDesignProps bool) ([]byte, bool, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, false, fmt.Errorf("unmarshal: %w", err) + } + + found := applyStyling(&doc, widgetName, changes, clearDesignProps) + if !found { + return data, false, nil + } + + out, err := bson.Marshal(doc) + if err != nil { + return nil, false, fmt.Errorf("marshal: %w", err) + } + return out, true, nil +} + +func applyStyling(doc *bson.D, widgetName string, changes map[string]string, clearDesignProps bool) bool { + name := "" + for _, e := range *doc { + if e.Key == "Name" { + name, _ = e.Value.(string) + break + } + } + if name == widgetName { + for prop, val := range changes { + switch prop { + case "Class", "Style": + *doc = SetBSONDocField(*doc, prop, val) + default: + // Design property + applyDesignProp(doc, prop, val) + } + } + if clearDesignProps { + *doc = SetBSONDocField(*doc, "DesignProperties", bson.D{}) + } + return true + } + + for i, e := range *doc { + switch v := e.Value.(type) { + case bson.D: + if applyStyling(&v, widgetName, changes, clearDesignProps) { + (*doc)[i].Value = v + return true + } + case bson.A: + if applyStylingArr(&v, widgetName, changes, clearDesignProps) { + (*doc)[i].Value = v + return true + } + } + } + return false +} + +func applyStylingArr(arr *bson.A, widgetName string, changes map[string]string, clearDesignProps bool) bool { + for i, item := range *arr { + if v, ok := item.(bson.D); ok { + if applyStyling(&v, widgetName, changes, clearDesignProps) { + (*arr)[i] = v + return true + } + } + } + return false +} + +func applyDesignProp(doc *bson.D, prop, val string) { + for i, e := range *doc { + if e.Key == "DesignProperties" { + if dp, ok := e.Value.(bson.D); ok { + dp = SetBSONDocField(dp, prop, val) + (*doc)[i].Value = dp + return + } + } + } + *doc = append(*doc, bson.E{Key: "DesignProperties", Value: bson.D{ + {Key: prop, Value: val}, + }}) +} + +// CollectWidgetStyling recursively collects styling info from a BSON document tree. +// Returns rows of [widgetName, class, style]. +func CollectWidgetStyling(data []byte, filterWidget string) ([][]string, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + var rows [][]string + collectStyling(&doc, filterWidget, &rows) + return rows, nil +} + +func collectStyling(doc *bson.D, filterWidget string, rows *[][]string) { + widgetName := "" + class := "" + style := "" + + for _, e := range *doc { + switch e.Key { + case "Name": + if s, ok := e.Value.(string); ok { + widgetName = s + } + case "Class": + if s, ok := e.Value.(string); ok { + class = s + } + case "Style": + if s, ok := e.Value.(string); ok { + style = s + } + } + } + + if widgetName != "" && (class != "" || style != "") { + if filterWidget == "" || widgetName == filterWidget { + *rows = append(*rows, []string{widgetName, class, style}) + } + } + + for _, e := range *doc { + switch v := e.Value.(type) { + case bson.D: + collectStyling(&v, filterWidget, rows) + case bson.A: + for _, item := range v { + if d, ok := item.(bson.D); ok { + collectStyling(&d, filterWidget, rows) + } + } + } + } +} + +// FindWidgetByName searches for a widget with the given name in a BSON doc tree. +// Returns a textual description of the widget subtree, or empty string if not found. +func FindWidgetByName(data []byte, name string) (bson.D, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + return findWidget(&doc, name), nil +} + +func findWidget(doc *bson.D, name string) bson.D { + for _, e := range *doc { + if e.Key == "Name" { + if s, ok := e.Value.(string); ok && s == name { + return *doc + } + } + } + for _, e := range *doc { + switch v := e.Value.(type) { + case bson.D: + if result := findWidget(&v, name); result != nil { + return result + } + case bson.A: + for _, item := range v { + if d, ok := item.(bson.D); ok { + if result := findWidget(&d, name); result != nil { + return result + } + } + } + } + } + return nil +} + +// DescribeWidgetTree produces a textual representation of a widget subtree. +func DescribeWidgetTree(doc bson.D, indent int) string { + var result string + result = describeTree(&doc, indent) + return result +} + +func describeTree(doc *bson.D, indent int) string { + prefix := "" + for i := 0; i < indent; i++ { + prefix += " " + } + widgetType := "" + widgetName := "" + for _, e := range *doc { + if e.Key == "$Type" { + widgetType, _ = e.Value.(string) + } + if e.Key == "Name" { + widgetName, _ = e.Value.(string) + } + } + result := "" + if widgetType != "" { + result += fmt.Sprintf("%s%s", prefix, widgetType) + if widgetName != "" { + result += fmt.Sprintf(" (%s)", widgetName) + } + result += "\n" + } + + for _, e := range *doc { + switch v := e.Value.(type) { + case bson.D: + hasType := false + for _, f := range v { + if f.Key == "$Type" { + hasType = true + break + } + } + if hasType { + result += describeTree(&v, indent+1) + } + case bson.A: + for _, item := range v { + if d, ok := item.(bson.D); ok { + hasType := false + for _, f := range d { + if f.Key == "$Type" { + hasType = true + break + } + } + if hasType { + result += describeTree(&d, indent+1) + } + } + } + } + } + return result +} + +// --------------------------------------------------------------------------- +// Widget update helpers +// --------------------------------------------------------------------------- + +// WidgetFilter describes a filter condition for matching widgets. +type WidgetFilter struct { + Field string + Operator string // "=" or "LIKE" + Value string +} + +// WidgetAssignment describes a property to set on matched widgets. +type WidgetAssignment struct { + PropertyPath string + Value any +} + +// UpdateWidgets recursively traverses a BSON document looking for widget +// nodes that match the filters, applying assignments to matching ones. +// Returns (modifiedData, matchCount, error). +func UpdateWidgets(data []byte, filters []WidgetFilter, assignments []WidgetAssignment, dryRun bool) ([]byte, int, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, 0, fmt.Errorf("unmarshal: %w", err) + } + + count := updateWidgetsDoc(&doc, filters, assignments, dryRun) + + if count > 0 && !dryRun { + out, err := bson.Marshal(doc) + if err != nil { + return nil, 0, fmt.Errorf("marshal: %w", err) + } + return out, count, nil + } + return data, count, nil +} + +func updateWidgetsDoc(doc *bson.D, filters []WidgetFilter, assignments []WidgetAssignment, dryRun bool) int { + count := 0 + for i, e := range *doc { + switch v := e.Value.(type) { + case bson.D: + if matchesFilters(v, filters) { + if !dryRun { + for _, a := range assignments { + v = SetBSONDocField(v, a.PropertyPath, a.Value) + } + (*doc)[i].Value = v + } + count++ + } + count += updateWidgetsDoc(&v, filters, assignments, dryRun) + (*doc)[i].Value = v + case bson.A: + count += updateWidgetsArr(&v, filters, assignments, dryRun) + (*doc)[i].Value = v + } + } + return count +} + +func updateWidgetsArr(arr *bson.A, filters []WidgetFilter, assignments []WidgetAssignment, dryRun bool) int { + count := 0 + for i, item := range *arr { + switch v := item.(type) { + case bson.D: + if matchesFilters(v, filters) { + if !dryRun { + for _, a := range assignments { + v = SetBSONDocField(v, a.PropertyPath, a.Value) + } + (*arr)[i] = v + } + count++ + } + count += updateWidgetsDoc(&v, filters, assignments, dryRun) + (*arr)[i] = v + case bson.A: + count += updateWidgetsArr(&v, filters, assignments, dryRun) + (*arr)[i] = v + } + } + return count +} + +func matchesFilters(doc bson.D, filters []WidgetFilter) bool { + if len(filters) == 0 { + return false + } + for _, f := range filters { + val := "" + for _, e := range doc { + if e.Key == f.Field || (f.Field == "WidgetType" && e.Key == "$Type") { + val, _ = e.Value.(string) + break + } + } + if f.Operator == "=" && val != f.Value { + return false + } + if f.Operator == "LIKE" { + if len(val) == 0 || !containsStr(val, f.Value) { + return false + } + } + } + return true +} + +func containsStr(s, substr string) bool { + return len(s) >= len(substr) && (s == substr || len(substr) == 0 || + findSubstr(s, substr)) +} + +func findSubstr(s, substr string) bool { + for i := 0; i <= len(s)-len(substr); i++ { + if s[i:i+len(substr)] == substr { + return true + } + } + return false +} + +// --------------------------------------------------------------------------- +// ALTER helpers for versioned arrays +// --------------------------------------------------------------------------- + +// AppendToVersionedArray appends a builder's document to a versioned array +// field in a BSON document. If the array doesn't exist, creates it with +// the version marker int32(3). +func AppendToVersionedArray(data []byte, arrayKey string, item *BSONDocBuilder) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + + found := false + for i, e := range doc { + if e.Key == arrayKey { + if arr, ok := e.Value.(bson.A); ok { + arr = append(arr, item.doc) + doc[i].Value = arr + found = true + } + break + } + } + if !found { + doc = append(doc, bson.E{Key: arrayKey, Value: bson.A{int32(3), item.doc}}) + } + return bson.Marshal(doc) +} + +// RemoveFromVersionedArrayByName removes an element from a versioned array +// where the element has a "Name" field matching the given name. +func RemoveFromVersionedArrayByName(data []byte, arrayKey, name string) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + + for i, e := range doc { + if e.Key == arrayKey { + if arr, ok := e.Value.(bson.A); ok { + newArr := bson.A{int32(3)} + for _, item := range arr[1:] { // skip version marker + if resDoc, ok := item.(bson.D); ok { + nameMatch := false + for _, field := range resDoc { + if field.Key == "Name" { + if s, ok := field.Value.(string); ok && s == name { + nameMatch = true + } + } + } + if !nameMatch { + newArr = append(newArr, item) + } + } + } + doc[i].Value = newArr + } + break + } + } + return bson.Marshal(doc) +} diff --git a/modelsdk/codec/bsondoc.go b/modelsdk/codec/bsondoc.go new file mode 100644 index 00000000..63f911cc --- /dev/null +++ b/modelsdk/codec/bsondoc.go @@ -0,0 +1,585 @@ +package codec + +import ( + "fmt" + + "go.mongodb.org/mongo-driver/bson" +) + +// --------------------------------------------------------------------------- +// BSONDocument — opaque wrapper around bson.D for engine/ callers. +// +// This type lets engine/ read, modify, and construct BSON documents without +// importing go.mongodb.org/mongo-driver/bson. All bson.D manipulation is +// encapsulated here. +// --------------------------------------------------------------------------- + +// BSONDocument wraps a parsed BSON document for in-place manipulation. +type BSONDocument struct { + doc bson.D +} + +// BSONArray wraps a parsed BSON array for in-place manipulation. +type BSONArray struct { + arr bson.A +} + +// ParseBSON deserializes raw BSON bytes into a BSONDocument. +func ParseBSON(data []byte) (*BSONDocument, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + return &BSONDocument{doc: doc}, nil +} + +// Marshal serializes the document back to raw BSON bytes. +func (d *BSONDocument) Marshal() ([]byte, error) { + return bson.Marshal(d.doc) +} + +// ToBuilder converts a BSONDocument to a BSONDocBuilder, sharing the +// underlying bson.D. This allows passing parsed documents to APIs that +// expect *BSONDocBuilder (e.g. InsertWidgetsNear, ReplaceWidgetByName). +func (d *BSONDocument) ToBuilder() *BSONDocBuilder { + return &BSONDocBuilder{doc: d.doc} +} + +// --------------------------------------------------------------------------- +// Field getters +// --------------------------------------------------------------------------- + +// GetString returns a string field value, or "" if not found. +func (d *BSONDocument) GetString(key string) string { + return getString(d.doc, key) +} + +// GetInt32 returns an int32 field value, or 0 if not found. +func (d *BSONDocument) GetInt32(key string) int32 { + for _, e := range d.doc { + if e.Key == key { + if v, ok := e.Value.(int32); ok { + return v + } + } + } + return 0 +} + +// GetBool returns a bool field value, or false if not found. +func (d *BSONDocument) GetBool(key string) bool { + for _, e := range d.doc { + if e.Key == key { + if v, ok := e.Value.(bool); ok { + return v + } + } + } + return false +} + +// GetDoc returns a nested document, or nil if not found. +func (d *BSONDocument) GetDoc(key string) *BSONDocument { + for _, e := range d.doc { + if e.Key == key { + if v, ok := e.Value.(bson.D); ok { + return &BSONDocument{doc: v} + } + } + } + return nil +} + +// GetArray returns a nested array, or an empty versioned array if not found. +func (d *BSONDocument) GetArray(key string) *BSONArray { + for _, e := range d.doc { + if e.Key == key { + if v, ok := e.Value.(bson.A); ok { + return &BSONArray{arr: v} + } + } + } + return &BSONArray{arr: bson.A{int32(3)}} +} + +// Has checks whether a field exists. +func (d *BSONDocument) Has(key string) bool { + for _, e := range d.doc { + if e.Key == key { + return true + } + } + return false +} + +// --------------------------------------------------------------------------- +// Field setters +// --------------------------------------------------------------------------- + +// Set sets or replaces a field with any value. +func (d *BSONDocument) Set(key string, value any) *BSONDocument { + d.doc = SetBSONDocField(d.doc, key, value) + return d +} + +// SetDoc sets or replaces a field with a nested document. +func (d *BSONDocument) SetDoc(key string, child *BSONDocument) *BSONDocument { + d.doc = SetBSONDocField(d.doc, key, child.doc) + return d +} + +// SetArray sets or replaces a field with an array. +func (d *BSONDocument) SetArray(key string, arr *BSONArray) *BSONDocument { + d.doc = SetBSONDocField(d.doc, key, arr.arr) + return d +} + +// SetBuilder sets or replaces a field with a BSONDocBuilder document. +func (d *BSONDocument) SetBuilder(key string, b *BSONDocBuilder) *BSONDocument { + d.doc = SetBSONDocField(d.doc, key, b.doc) + return d +} + +// Remove removes a field by key. +func (d *BSONDocument) Remove(key string) *BSONDocument { + newDoc := make(bson.D, 0, len(d.doc)) + for _, e := range d.doc { + if e.Key != key { + newDoc = append(newDoc, e) + } + } + d.doc = newDoc + return d +} + +// --------------------------------------------------------------------------- +// BSONArray methods +// --------------------------------------------------------------------------- + +// Len returns the number of elements (excluding version marker). +func (a *BSONArray) Len() int { + count := 0 + for _, item := range a.arr { + if _, ok := item.(bson.D); ok { + count++ + } + } + return count +} + +// Doc returns the document at index i (skipping version markers). +func (a *BSONArray) Doc(i int) *BSONDocument { + idx := 0 + for _, item := range a.arr { + if d, ok := item.(bson.D); ok { + if idx == i { + return &BSONDocument{doc: d} + } + idx++ + } + } + return nil +} + +// FindByName finds a document in the array where field "Name" matches. +// Returns the document and its raw index in the array, or (nil, -1). +func (a *BSONArray) FindByName(name string) (*BSONDocument, int) { + return a.FindByField("Name", name) +} + +// FindByField finds a document in the array where the given field matches. +// Returns the document and its raw index in the array, or (nil, -1). +func (a *BSONArray) FindByField(field, value string) (*BSONDocument, int) { + for i, item := range a.arr { + if d, ok := item.(bson.D); ok { + for _, e := range d { + if e.Key == field { + if s, ok := e.Value.(string); ok && s == value { + return &BSONDocument{doc: d}, i + } + } + } + } + } + return nil, -1 +} + +// Append adds a document to the array. +func (a *BSONArray) Append(doc *BSONDocument) { + a.arr = append(a.arr, doc.doc) +} + +// AppendBuilder adds a BSONDocBuilder document to the array. +func (a *BSONArray) AppendBuilder(b *BSONDocBuilder) { + a.arr = append(a.arr, b.doc) +} + +// InsertAt inserts a document at the given raw array index, shifting +// subsequent elements to the right. +func (a *BSONArray) InsertAt(rawIdx int, doc *BSONDocument) { + if rawIdx < 0 || rawIdx > len(a.arr) { + a.arr = append(a.arr, doc.doc) + return + } + a.arr = append(a.arr, nil) + copy(a.arr[rawIdx+1:], a.arr[rawIdx:]) + a.arr[rawIdx] = doc.doc +} + +// RemoveAt removes the element at the given raw array index. +func (a *BSONArray) RemoveAt(rawIdx int) { + if rawIdx >= 0 && rawIdx < len(a.arr) { + a.arr = append(a.arr[:rawIdx], a.arr[rawIdx+1:]...) + } +} + +// Update replaces the document at the given raw array index. +func (a *BSONArray) Update(rawIdx int, doc *BSONDocument) { + if rawIdx >= 0 && rawIdx < len(a.arr) { + a.arr[rawIdx] = doc.doc + } +} + +// Each iterates over document elements in the array, calling fn for each. +// fn receives the document and its raw array index. Return false to stop. +func (a *BSONArray) Each(fn func(doc *BSONDocument, rawIdx int) bool) { + for i, item := range a.arr { + if d, ok := item.(bson.D); ok { + if !fn(&BSONDocument{doc: d}, i) { + return + } + } + } +} + +// NewVersionedArray creates a new empty array with the Mendix version marker. +func NewVersionedArray() *BSONArray { + return &BSONArray{arr: bson.A{int32(3)}} +} + +// NewEmptyDoc creates a new empty BSONDocument. +func NewEmptyDoc() *BSONDocument { + return &BSONDocument{doc: bson.D{}} +} + +// --------------------------------------------------------------------------- +// Recursive widget-tree helpers for ALTER PAGE operations. +// These let engine/ traverse and mutate BSON widget trees without +// importing bson types. +// --------------------------------------------------------------------------- + +// WalkWidgets recursively walks the widget tree in this document, +// calling fn for each document that has a "$Type" field. The walk +// descends into "Widgets" and "Arguments" array fields. +// fn receives each widget doc; return true from fn to stop early. +// Returns true if early-stopped. +func (d *BSONDocument) WalkWidgets(fn func(widget *BSONDocument) bool) bool { + return walkWidgetDoc(d, fn) +} + +func walkWidgetDoc(d *BSONDocument, fn func(*BSONDocument) bool) bool { + if d.Has("$Type") { + if fn(d) { + return true + } + } + for _, key := range []string{"Widgets", "Arguments", "LayoutCall"} { + for i, e := range d.doc { + if e.Key != key { + continue + } + switch v := e.Value.(type) { + case bson.D: + child := &BSONDocument{doc: v} + if walkWidgetDoc(child, fn) { + d.doc[i].Value = child.doc + return true + } + d.doc[i].Value = child.doc + case bson.A: + arr := &BSONArray{arr: v} + if walkWidgetArr(arr, fn) { + d.doc[i].Value = arr.arr + return true + } + d.doc[i].Value = arr.arr + } + } + } + return false +} + +func walkWidgetArr(a *BSONArray, fn func(*BSONDocument) bool) bool { + for i, item := range a.arr { + if raw, ok := item.(bson.D); ok { + child := &BSONDocument{doc: raw} + if walkWidgetDoc(child, fn) { + a.arr[i] = child.doc + return true + } + a.arr[i] = child.doc + } + } + return false +} + +// ModifyWidgetByName finds a widget with the given Name field in the +// document tree and calls fn to modify it. Returns true if found. +func (d *BSONDocument) ModifyWidgetByName(name string, fn func(widget *BSONDocument)) bool { + return modifyByName(d, name, fn) +} + +func modifyByName(d *BSONDocument, name string, fn func(*BSONDocument)) bool { + if d.GetString("Name") == name { + fn(d) + return true + } + for _, key := range []string{"Widgets", "Arguments", "LayoutCall"} { + for i, e := range d.doc { + if e.Key != key { + continue + } + switch v := e.Value.(type) { + case bson.D: + child := &BSONDocument{doc: v} + if modifyByName(child, name, fn) { + d.doc[i].Value = child.doc + return true + } + case bson.A: + for j, item := range v { + if raw, ok := item.(bson.D); ok { + child := &BSONDocument{doc: raw} + if modifyByName(child, name, fn) { + v[j] = child.doc + d.doc[i].Value = v + return true + } + } + } + } + } + } + return false +} + +// RemoveWidgetByName removes a widget with the given Name from the +// document's widget tree. Returns true if the widget was found and removed. +func (d *BSONDocument) RemoveWidgetByName(name string) bool { + return removeByName(d, name) +} + +func removeByName(d *BSONDocument, name string) bool { + for i, e := range d.doc { + if e.Key != "Widgets" && e.Key != "Arguments" { + continue + } + arr, ok := e.Value.(bson.A) + if !ok { + continue + } + // Check direct children first + for j, item := range arr { + raw, ok := item.(bson.D) + if !ok { + continue + } + if getString(raw, "Name") == name { + // Remove this element + newArr := make(bson.A, 0, len(arr)-1) + newArr = append(newArr, arr[:j]...) + newArr = append(newArr, arr[j+1:]...) + d.doc[i].Value = newArr + return true + } + } + // Recurse into children + for j, item := range arr { + raw, ok := item.(bson.D) + if !ok { + continue + } + child := &BSONDocument{doc: raw} + if removeByName(child, name) { + arr[j] = child.doc + d.doc[i].Value = arr + return true + } + } + } + // Also check nested docs (like LayoutCall) + for i, e := range d.doc { + if raw, ok := e.Value.(bson.D); ok { + child := &BSONDocument{doc: raw} + if removeByName(child, name) { + d.doc[i].Value = child.doc + return true + } + } + } + return false +} + +// InsertWidgetsNear inserts builder documents before or after a named +// widget in the document tree. position is "BEFORE" or "AFTER". +// Returns true if the target widget was found. +func (d *BSONDocument) InsertWidgetsNear(targetName, position string, widgets []*BSONDocBuilder) bool { + return insertNear(d, targetName, position, widgets) +} + +func insertNear(d *BSONDocument, targetName, position string, widgets []*BSONDocBuilder) bool { + for i, e := range d.doc { + if e.Key != "Widgets" && e.Key != "Arguments" { + continue + } + arr, ok := e.Value.(bson.A) + if !ok { + continue + } + for j, item := range arr { + raw, ok := item.(bson.D) + if !ok { + continue + } + if getString(raw, "Name") == targetName { + idx := j + if position == "AFTER" { + idx = j + 1 + } + newArr := make(bson.A, 0, len(arr)+len(widgets)) + newArr = append(newArr, arr[:idx]...) + for _, w := range widgets { + newArr = append(newArr, w.doc) + } + newArr = append(newArr, arr[idx:]...) + d.doc[i].Value = newArr + return true + } + // Recurse + child := &BSONDocument{doc: raw} + if insertNear(child, targetName, position, widgets) { + arr[j] = child.doc + d.doc[i].Value = arr + return true + } + } + } + // Also check nested docs (like LayoutCall) + for i, e := range d.doc { + if raw, ok := e.Value.(bson.D); ok { + child := &BSONDocument{doc: raw} + if insertNear(child, targetName, position, widgets) { + d.doc[i].Value = child.doc + return true + } + } + } + return false +} + +// ReplaceWidgetByName replaces a named widget with one or more new +// widget builders. Returns true if the target was found and replaced. +func (d *BSONDocument) ReplaceWidgetByName(targetName string, widgets []*BSONDocBuilder) bool { + return replaceByName(d, targetName, widgets) +} + +func replaceByName(d *BSONDocument, targetName string, widgets []*BSONDocBuilder) bool { + for i, e := range d.doc { + if e.Key != "Widgets" && e.Key != "Arguments" { + continue + } + arr, ok := e.Value.(bson.A) + if !ok { + continue + } + for j, item := range arr { + raw, ok := item.(bson.D) + if !ok { + continue + } + if getString(raw, "Name") == targetName { + newArr := make(bson.A, 0, len(arr)-1+len(widgets)) + newArr = append(newArr, arr[:j]...) + for _, w := range widgets { + newArr = append(newArr, w.doc) + } + newArr = append(newArr, arr[j+1:]...) + d.doc[i].Value = newArr + return true + } + // Recurse + child := &BSONDocument{doc: raw} + if replaceByName(child, targetName, widgets) { + arr[j] = child.doc + d.doc[i].Value = arr + return true + } + } + } + // Also check nested docs (like LayoutCall) + for i, e := range d.doc { + if raw, ok := e.Value.(bson.D); ok { + child := &BSONDocument{doc: raw} + if replaceByName(child, targetName, widgets) { + d.doc[i].Value = child.doc + return true + } + } + } + return false +} + +// AppendToVersionedArray appends a BSONDocBuilder document to the named +// versioned array field, creating the array with version marker if needed. +func (d *BSONDocument) AppendToVersionedArray(key string, item *BSONDocBuilder) { + for i, e := range d.doc { + if e.Key == key { + if arr, ok := e.Value.(bson.A); ok { + d.doc[i].Value = append(arr, item.doc) + return + } + } + } + d.doc = append(d.doc, bson.E{Key: key, Value: bson.A{int32(3), item.doc}}) +} + +// RemoveFromVersionedArrayByField removes elements from a versioned array +// where the given field matches one of the provided values. +func (d *BSONDocument) RemoveFromVersionedArrayByField(arrayKey, fieldKey string, matchValues ...string) { + matchSet := make(map[string]bool, len(matchValues)) + for _, v := range matchValues { + matchSet[v] = true + } + for i, e := range d.doc { + if e.Key != arrayKey { + continue + } + arr, ok := e.Value.(bson.A) + if !ok { + return + } + newArr := bson.A{} + for _, item := range arr { + if raw, ok := item.(bson.D); ok { + if matchSet[getString(raw, fieldKey)] { + continue + } + } + newArr = append(newArr, item) + } + d.doc[i].Value = newArr + return + } +} + +// GetValue returns the raw value for a field, or nil if not found. +// This is used when the caller needs to pass through opaque values +// (e.g., for SET operations on arbitrary properties). +func (d *BSONDocument) GetValue(key string) any { + for _, e := range d.doc { + if e.Key == key { + return e.Value + } + } + return nil +} diff --git a/modelsdk/codec/bsonutil.go b/modelsdk/codec/bsonutil.go new file mode 100644 index 00000000..c0985312 --- /dev/null +++ b/modelsdk/codec/bsonutil.go @@ -0,0 +1,595 @@ +package codec + +import ( + "fmt" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "go.mongodb.org/mongo-driver/bson" +) + +// --------------------------------------------------------------------------- +// Bridge helpers — raw BSON operations exposed to engine/ so that engine/ +// never imports go.mongodb.org/mongo-driver/bson directly. +// +// DO NOT add type aliases (type D = bson.D) or marshal wrappers here. +// engine/ must use modelsdk/gen/* SDK constructors, not raw BSON types. +// --------------------------------------------------------------------------- + +// SetBSONDocField sets or replaces a key in a parsed bson.D document. +// This is the in-memory equivalent of PatchBSONField (which works on []byte). +// Use this when the caller already has a bson.D from tree traversal. +func SetBSONDocField(doc bson.D, key string, val any) bson.D { + for i, e := range doc { + if e.Key == key { + doc[i].Value = val + return doc + } + } + return append(doc, bson.E{Key: key, Value: val}) +} + +// PatchBSONField sets or replaces a top-level field in a BSON document. +func PatchBSONField(data []byte, key string, value any) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + found := false + for i, e := range doc { + if e.Key == key { + doc[i].Value = value + found = true + break + } + } + if !found { + doc = append(doc, bson.E{Key: key, Value: value}) + } + return bson.Marshal(doc) +} + +// PatchBSONArrayAppend appends a value to a versioned BSON array field. +func PatchBSONArrayAppend(data []byte, key string, value any) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + for i, e := range doc { + if e.Key == key { + if arr, ok := e.Value.(bson.A); ok { + doc[i].Value = append(arr, value) + } + break + } + } + return bson.Marshal(doc) +} + +// PatchBSONArrayRemove removes a string value from a versioned BSON array field. +// Preserves the int32(3) version marker. +func PatchBSONArrayRemove(data []byte, key string, value string) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + for i, e := range doc { + if e.Key != key { + continue + } + arr, ok := e.Value.(bson.A) + if !ok { + break + } + newArr := bson.A{} + for _, item := range arr { + if s, ok := item.(string); ok && s == value { + continue + } + newArr = append(newArr, item) + } + doc[i].Value = newArr + break + } + return bson.Marshal(doc) +} + +// ReadBSONFieldString reads a string field from raw BSON bytes. +func ReadBSONFieldString(data []byte, key string) (string, error) { + raw := bson.Raw(data) + val, err := raw.LookupErr(key) + if err != nil { + return "", fmt.Errorf("field %q not found", key) + } + s, ok := val.StringValueOK() + if !ok { + return "", fmt.Errorf("field %q is not a string", key) + } + return s, nil +} + +// PatchNestedRefList patches a ByNameRefList field on a nested document +// identified by a name field within a versioned array. Used for patterns like: +// +// doc.UserRoles[Name=="Admin"].ModuleRoles = ["Module.Role1", "Module.Role2"] +func PatchNestedRefList(data []byte, arrayKey, nameKey, nameValue, refListKey string, refs []string) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + for i, e := range doc { + if e.Key != arrayKey { + continue + } + arr, ok := e.Value.(bson.A) + if !ok { + continue + } + for j, item := range arr { + d, ok := item.(bson.D) + if !ok { + continue + } + matched := false + for _, f := range d { + if f.Key == nameKey { + if s, ok := f.Value.(string); ok && s == nameValue { + matched = true + } + } + } + if !matched { + continue + } + rolesArr := bson.A{int32(3)} + for _, r := range refs { + rolesArr = append(rolesArr, r) + } + found := false + for k, f := range d { + if f.Key == refListKey { + d[k].Value = rolesArr + found = true + break + } + } + if !found { + d = append(d, bson.E{Key: refListKey, Value: rolesArr}) + } + arr[j] = d + } + doc[i].Value = arr + } + return bson.Marshal(doc) +} + +// PatchDocumentAllowedRoles adds or removes role strings from a versioned array +// field (AllowedModuleRoles, AllowedRoles, etc.) on a document. +// action must be "add" or "remove". +func PatchDocumentAllowedRoles(data []byte, fieldKey, action string, roles []string) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + + fieldIdx := -1 + for i, e := range doc { + if e.Key == fieldKey { + fieldIdx = i + break + } + } + + if fieldIdx < 0 && action == "add" { + // Field doesn't exist yet — create it with the version marker. + arr := bson.A{int32(3)} + for _, r := range roles { + arr = append(arr, r) + } + doc = append(doc, bson.E{Key: fieldKey, Value: arr}) + return bson.Marshal(doc) + } + if fieldIdx < 0 { + // Nothing to remove from a non-existent field. + return bson.Marshal(doc) + } + + arr, ok := doc[fieldIdx].Value.(bson.A) + if !ok { + return bson.Marshal(doc) + } + + if action == "add" { + existing := make(map[string]bool) + for _, item := range arr { + if s, ok := item.(string); ok { + existing[s] = true + } + } + for _, r := range roles { + if !existing[r] { + arr = append(arr, r) + } + } + } else { // remove + removeSet := make(map[string]bool, len(roles)) + for _, r := range roles { + removeSet[r] = true + } + newArr := bson.A{} + for _, item := range arr { + if s, ok := item.(string); ok && removeSet[s] { + continue + } + newArr = append(newArr, item) + } + arr = newArr + } + doc[fieldIdx].Value = arr + return bson.Marshal(doc) +} + +// PatchEntityAccessRuleRoles patches ModuleRoles on an access rule within a +// nested entity inside a DomainModel document. If isNew is true, the last access +// rule is patched (the newly added one). Otherwise, it finds the access rule +// whose existing ModuleRoles match roleNames. +func PatchEntityAccessRuleRoles(data []byte, entityName string, roleNames []string, isNew bool) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + + entities := getArray(doc, "Entities") + for ei, eItem := range entities { + ed, ok := eItem.(bson.D) + if !ok { + continue + } + if getString(ed, "Name") != entityName { + continue + } + + accessRules := getArray(ed, "AccessRules") + + rolesArr := bson.A{int32(3)} + for _, rn := range roleNames { + rolesArr = append(rolesArr, rn) + } + + if isNew { + if len(accessRules) > 0 { + lastIdx := len(accessRules) - 1 + if ruleDoc, ok := accessRules[lastIdx].(bson.D); ok { + ruleDoc = SetBSONDocField(ruleDoc, "ModuleRoles", rolesArr) + accessRules[lastIdx] = ruleDoc + } + } + } else { + for ri, rItem := range accessRules { + ruleDoc, ok := rItem.(bson.D) + if !ok { + continue + } + existingRoles := getArray(ruleDoc, "ModuleRoles") + if matchRoleNames(existingRoles, roleNames) { + ruleDoc = SetBSONDocField(ruleDoc, "ModuleRoles", rolesArr) + accessRules[ri] = ruleDoc + break + } + } + } + + ed = SetBSONDocField(ed, "AccessRules", accessRules) + entities[ei] = ed + break + } + + doc = SetBSONDocField(doc, "Entities", entities) + return bson.Marshal(doc) +} + +// getString returns the string value for the given key, or "". +func getString(doc bson.D, key string) string { + for _, e := range doc { + if e.Key == key { + if s, ok := e.Value.(string); ok { + return s + } + } + } + return "" +} + +// getArray returns the bson.A for the given key, or an empty bson.A with version marker. +func getArray(doc bson.D, key string) bson.A { + for _, e := range doc { + if e.Key == key { + if a, ok := e.Value.(bson.A); ok { + return a + } + } + } + return bson.A{int32(3)} +} + +// matchRoleNames checks if a BSON roles array contains the same set of role names. +func matchRoleNames(rolesArr bson.A, roleNames []string) bool { + var existing []string + for _, item := range rolesArr { + if s, ok := item.(string); ok { + existing = append(existing, s) + } + } + if len(existing) != len(roleNames) { + return false + } + set := make(map[string]bool, len(existing)) + for _, r := range existing { + set[r] = true + } + for _, r := range roleNames { + if !set[r] { + return false + } + } + return true +} + +// AppendEncodedToVersionedArray encodes an element.Element via the codec +// Encoder and appends the resulting bson.D to a versioned array field in data. +// This replaces the pattern of NewBSONDoc().Set(...) + AppendToVersionedArray +// with SDK constructors + encode + append. +func AppendEncodedToVersionedArray(data []byte, arrayKey string, elem element.Element) ([]byte, error) { + enc := &Encoder{} + encoded, err := enc.Encode(elem) + if err != nil { + return nil, fmt.Errorf("encode element: %w", err) + } + var elemDoc bson.D + if err := bson.Unmarshal(encoded, &elemDoc); err != nil { + return nil, fmt.Errorf("unmarshal encoded element: %w", err) + } + + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal data: %w", err) + } + found := false + for i, e := range doc { + if e.Key == arrayKey { + if arr, ok := e.Value.(bson.A); ok { + arr = append(arr, elemDoc) + doc[i].Value = arr + found = true + } + break + } + } + if !found { + doc = append(doc, bson.E{Key: arrayKey, Value: bson.A{int32(3), elemDoc}}) + } + return bson.Marshal(doc) +} + +// PatchNestedBSONField sets or replaces a field inside a sub-document. +// parentKey identifies the top-level field that contains the sub-document, +// childKey is the field within that sub-document to set. +func PatchNestedBSONField(data []byte, parentKey, childKey string, value any) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + for i, e := range doc { + if e.Key != parentKey { + continue + } + child, ok := e.Value.(bson.D) + if !ok { + continue + } + doc[i].Value = SetBSONDocField(child, childKey, value) + return bson.Marshal(doc) + } + return bson.Marshal(doc) +} + +// PatchVersionedArrayElements patches fields on each element of a versioned +// BSON array by index. patches maps element index (0-based, skipping the +// version marker) to a map of field-name -> value. Used to add non-SDK fields +// to elements created by SDK constructors. +func PatchVersionedArrayElements(data []byte, arrayKey string, patches map[int]map[string]any) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + for i, e := range doc { + if e.Key != arrayKey { + continue + } + arr, ok := e.Value.(bson.A) + if !ok { + continue + } + // Versioned arrays start with int32(3) marker at index 0. + startIdx := 0 + if len(arr) > 0 { + if _, isInt := arr[0].(int32); isInt { + startIdx = 1 + } + } + for elemIdx, fields := range patches { + rawIdx := startIdx + elemIdx + if rawIdx >= len(arr) { + continue + } + d, ok := arr[rawIdx].(bson.D) + if !ok { + continue + } + for k, v := range fields { + d = SetBSONDocField(d, k, v) + } + arr[rawIdx] = d + } + doc[i].Value = arr + } + return bson.Marshal(doc) +} + +// RenameBSONField renames a top-level field key in a BSON document. +func RenameBSONField(data []byte, oldKey, newKey string) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + for i, e := range doc { + if e.Key == oldKey { + doc[i].Key = newKey + break + } + } + return bson.Marshal(doc) +} + +// RenameFieldInVersionedArrayElement renames a field key inside a specific +// element (by 0-based index, skipping version marker) of a versioned array. +func RenameFieldInVersionedArrayElement(data []byte, arrayKey string, elemIdx int, oldField, newField string) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + for i, e := range doc { + if e.Key != arrayKey { + continue + } + arr, ok := e.Value.(bson.A) + if !ok { + continue + } + startIdx := 0 + if len(arr) > 0 { + if _, isInt := arr[0].(int32); isInt { + startIdx = 1 + } + } + rawIdx := startIdx + elemIdx + if rawIdx >= len(arr) { + continue + } + d, ok := arr[rawIdx].(bson.D) + if !ok { + continue + } + for j, f := range d { + if f.Key == oldField { + d[j].Key = newField + break + } + } + arr[rawIdx] = d + doc[i].Value = arr + } + return bson.Marshal(doc) +} + +// PatchNestedVersionedArrayElements patches fields on elements of a versioned +// array that is nested inside a specific element of another versioned array. +// parentArrayKey and parentIdx identify the parent element; childArrayKey +// identifies the nested array within that element. +func PatchNestedVersionedArrayElements(data []byte, parentArrayKey string, parentIdx int, childArrayKey string, patches map[int]map[string]any) ([]byte, error) { + var doc bson.D + if err := bson.Unmarshal(data, &doc); err != nil { + return nil, fmt.Errorf("unmarshal: %w", err) + } + for i, e := range doc { + if e.Key != parentArrayKey { + continue + } + arr, ok := e.Value.(bson.A) + if !ok { + continue + } + startIdx := 0 + if len(arr) > 0 { + if _, isInt := arr[0].(int32); isInt { + startIdx = 1 + } + } + rawIdx := startIdx + parentIdx + if rawIdx >= len(arr) { + continue + } + parentDoc, ok := arr[rawIdx].(bson.D) + if !ok { + continue + } + for pi, pe := range parentDoc { + if pe.Key != childArrayKey { + continue + } + childArr, ok := pe.Value.(bson.A) + if !ok { + continue + } + childStart := 0 + if len(childArr) > 0 { + if _, isInt := childArr[0].(int32); isInt { + childStart = 1 + } + } + for childIdx, fields := range patches { + childRawIdx := childStart + childIdx + if childRawIdx >= len(childArr) { + continue + } + d, ok := childArr[childRawIdx].(bson.D) + if !ok { + continue + } + for k, v := range fields { + d = SetBSONDocField(d, k, v) + } + childArr[childRawIdx] = d + } + parentDoc[pi].Value = childArr + } + arr[rawIdx] = parentDoc + doc[i].Value = arr + } + return bson.Marshal(doc) +} + +// ScanBSONStrings recursively scans a BSON document and calls fn for each +// string value found. fn receives (fieldPath, value). Return false from fn +// to stop scanning early. +func ScanBSONStrings(data []byte, fn func(fieldPath, value string) bool) { + scanBSONRaw(bson.Raw(data), "", fn) +} + +func scanBSONRaw(raw bson.Raw, prefix string, fn func(string, string) bool) { + elems, err := raw.Elements() + if err != nil { + return + } + for _, elem := range elems { + key := elem.Key() + fieldPath := key + if prefix != "" { + fieldPath = prefix + "." + key + } + val := elem.Value() + switch val.Type { + case bson.TypeString: + if !fn(fieldPath, val.StringValue()) { + return + } + case bson.TypeEmbeddedDocument: + if doc, ok := val.DocumentOK(); ok { + scanBSONRaw(doc, fieldPath, fn) + } + case bson.TypeArray: + if arr, ok := val.ArrayOK(); ok { + scanBSONRaw(bson.Raw(arr), fieldPath, fn) + } + } + } +} diff --git a/modelsdk/codec/bsonutil_test.go b/modelsdk/codec/bsonutil_test.go new file mode 100644 index 00000000..ab582065 --- /dev/null +++ b/modelsdk/codec/bsonutil_test.go @@ -0,0 +1,253 @@ +package codec_test + +import ( + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/codec" + "go.mongodb.org/mongo-driver/bson" +) + +func TestPatchBSONField_Update(t *testing.T) { + doc := bson.D{{Key: "Name", Value: "old"}, {Key: "Other", Value: int32(42)}} + data, _ := bson.Marshal(doc) + + result, err := codec.PatchBSONField(data, "Name", "new") + if err != nil { + t.Fatal(err) + } + + var out bson.D + if err := bson.Unmarshal(result, &out); err != nil { + t.Fatal(err) + } + for _, e := range out { + if e.Key == "Name" { + if e.Value != "new" { + t.Errorf("expected Name=new, got %v", e.Value) + } + return + } + } + t.Error("Name field not found") +} + +func TestPatchBSONField_Append(t *testing.T) { + doc := bson.D{{Key: "Name", Value: "test"}} + data, _ := bson.Marshal(doc) + + result, err := codec.PatchBSONField(data, "NewKey", "value") + if err != nil { + t.Fatal(err) + } + + var out bson.D + bson.Unmarshal(result, &out) + if len(out) != 2 { + t.Errorf("expected 2 fields, got %d", len(out)) + } +} + +func TestPatchBSONArrayAppend(t *testing.T) { + doc := bson.D{{Key: "Roles", Value: bson.A{int32(3), "Admin"}}} + data, _ := bson.Marshal(doc) + + result, err := codec.PatchBSONArrayAppend(data, "Roles", "User") + if err != nil { + t.Fatal(err) + } + + var out bson.D + bson.Unmarshal(result, &out) + for _, e := range out { + if e.Key == "Roles" { + arr := e.Value.(bson.A) + if len(arr) != 3 { + t.Errorf("expected 3 elements, got %d", len(arr)) + } + if arr[2] != "User" { + t.Errorf("expected last element User, got %v", arr[2]) + } + return + } + } + t.Error("Roles field not found") +} + +func TestPatchBSONArrayRemove(t *testing.T) { + doc := bson.D{{Key: "Roles", Value: bson.A{int32(3), "Admin", "User"}}} + data, _ := bson.Marshal(doc) + + result, err := codec.PatchBSONArrayRemove(data, "Roles", "Admin") + if err != nil { + t.Fatal(err) + } + + var out bson.D + bson.Unmarshal(result, &out) + for _, e := range out { + if e.Key == "Roles" { + arr := e.Value.(bson.A) + if len(arr) != 2 { // version marker + User + t.Errorf("expected 2 elements, got %d", len(arr)) + } + return + } + } + t.Error("Roles field not found") +} + +func TestReadBSONFieldString(t *testing.T) { + doc := bson.D{{Key: "Name", Value: "test"}} + data, _ := bson.Marshal(doc) + + val, err := codec.ReadBSONFieldString(data, "Name") + if err != nil { + t.Fatal(err) + } + if val != "test" { + t.Errorf("expected test, got %s", val) + } +} + +func TestReadBSONFieldString_NotFound(t *testing.T) { + doc := bson.D{{Key: "Other", Value: "test"}} + data, _ := bson.Marshal(doc) + + _, err := codec.ReadBSONFieldString(data, "Name") + if err == nil { + t.Error("expected error for missing field") + } +} + +func TestPatchNestedRefList(t *testing.T) { + inner := bson.D{ + {Key: "Name", Value: "Admin"}, + {Key: "ModuleRoles", Value: bson.A{int32(3)}}, + } + outer := bson.D{ + {Key: "UserRoles", Value: bson.A{int32(3), inner}}, + } + data, _ := bson.Marshal(outer) + + result, err := codec.PatchNestedRefList(data, "UserRoles", "Name", "Admin", "ModuleRoles", []string{"MyModule.User"}) + if err != nil { + t.Fatal(err) + } + + var out bson.D + bson.Unmarshal(result, &out) + for _, e := range out { + if e.Key == "UserRoles" { + arr := e.Value.(bson.A) + for _, item := range arr[1:] { + d := item.(bson.D) + for _, f := range d { + if f.Key == "ModuleRoles" { + roles := f.Value.(bson.A) + if len(roles) != 2 { // version marker + 1 role + t.Errorf("expected 2, got %d", len(roles)) + } + if roles[1] != "MyModule.User" { + t.Errorf("expected MyModule.User, got %v", roles[1]) + } + } + } + } + return + } + } + t.Error("UserRoles not found") +} + +func TestPatchDocumentAllowedRoles_Add(t *testing.T) { + doc := bson.D{{Key: "AllowedRoles", Value: bson.A{int32(3), "Admin"}}} + data, _ := bson.Marshal(doc) + + result, err := codec.PatchDocumentAllowedRoles(data, "AllowedRoles", "add", []string{"User", "Admin"}) + if err != nil { + t.Fatal(err) + } + + var out bson.D + bson.Unmarshal(result, &out) + for _, e := range out { + if e.Key == "AllowedRoles" { + arr := e.Value.(bson.A) + // version marker + Admin (existing) + User (new) — Admin not duplicated + if len(arr) != 3 { + t.Errorf("expected 3, got %d: %v", len(arr), arr) + } + return + } + } + t.Error("AllowedRoles not found") +} + +func TestPatchDocumentAllowedRoles_Remove(t *testing.T) { + doc := bson.D{{Key: "AllowedRoles", Value: bson.A{int32(3), "Admin", "User"}}} + data, _ := bson.Marshal(doc) + + result, err := codec.PatchDocumentAllowedRoles(data, "AllowedRoles", "remove", []string{"Admin"}) + if err != nil { + t.Fatal(err) + } + + var out bson.D + bson.Unmarshal(result, &out) + for _, e := range out { + if e.Key == "AllowedRoles" { + arr := e.Value.(bson.A) + if len(arr) != 2 { // version marker + User + t.Errorf("expected 2, got %d: %v", len(arr), arr) + } + return + } + } + t.Error("AllowedRoles not found") +} + +func TestScanBSONStrings(t *testing.T) { + doc := bson.D{ + {Key: "Name", Value: "hello"}, + {Key: "Count", Value: int32(5)}, + {Key: "Nested", Value: bson.D{ + {Key: "Inner", Value: "world"}, + }}, + } + data, _ := bson.Marshal(doc) + + var found []string + codec.ScanBSONStrings(data, func(path, val string) bool { + found = append(found, path+"="+val) + return true + }) + + if len(found) != 2 { + t.Errorf("expected 2 strings, got %d: %v", len(found), found) + } + if found[0] != "Name=hello" { + t.Errorf("expected Name=hello, got %s", found[0]) + } + if found[1] != "Nested.Inner=world" { + t.Errorf("expected Nested.Inner=world, got %s", found[1]) + } +} + +func TestScanBSONStrings_EarlyStop(t *testing.T) { + doc := bson.D{ + {Key: "A", Value: "first"}, + {Key: "B", Value: "second"}, + {Key: "C", Value: "third"}, + } + data, _ := bson.Marshal(doc) + + count := 0 + codec.ScanBSONStrings(data, func(_, _ string) bool { + count++ + return count < 2 + }) + + if count != 2 { + t.Errorf("expected early stop at 2, got %d", count) + } +} diff --git a/modelsdk/codec/codec_bench_test.go b/modelsdk/codec/codec_bench_test.go new file mode 100644 index 00000000..8b34f5bd --- /dev/null +++ b/modelsdk/codec/codec_bench_test.go @@ -0,0 +1,83 @@ +package codec + +import ( + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/primitive" +) + +func BenchmarkEncodeCleanPassthrough(b *testing.B) { + raw := mustMarshal(bson.D{ + {Key: "$ID", Value: primitive.Binary{Subtype: 0, Data: make([]byte, 16)}}, + {Key: "$Type", Value: "Test$Bench"}, + {Key: "name", Value: "entity"}, + {Key: "doc", Value: "some documentation"}, + {Key: "count", Value: int32(100)}, + }) + + elem := &element.Base{} + elem.SetRaw(raw) + + enc := &Encoder{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + enc.Encode(elem) + } +} + +func BenchmarkEncodeDirtyRebuild(b *testing.B) { + raw := mustMarshal(bson.D{ + {Key: "$ID", Value: primitive.Binary{Subtype: 0, Data: make([]byte, 16)}}, + {Key: "$Type", Value: "Test$Bench"}, + {Key: "name", Value: "original"}, + {Key: "doc", Value: "documentation"}, + }) + + enc := &Encoder{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + elem := &element.Base{} + elem.SetID("test-id") + elem.SetTypeName("Test$Bench") + elem.SetRaw(raw) + p := property.NewPrimitive[string]("name", property.DecodeString) + p.Init(raw) + p.Bind(elem, 0) + p.Set("modified") + elem.SetProperties([]element.Property{p}) + enc.Encode(elem) + } +} + +func BenchmarkDecodeUnknownType(b *testing.B) { + r := NewRegistry() + raw := mustMarshal(bson.D{ + {Key: "$ID", Value: "id-bench"}, + {Key: "$Type", Value: "Unknown$Type"}, + }) + dec := NewDecoder(r) + + b.ResetTimer() + for i := 0; i < b.N; i++ { + dec.Decode(raw) + } +} + +func BenchmarkDecodeRegisteredType(b *testing.B) { + r := NewRegistry() + r.Register("Test$Bench", func() element.Element { return &element.Base{} }) + raw := mustMarshal(bson.D{ + {Key: "$ID", Value: primitive.Binary{Subtype: 0, Data: make([]byte, 16)}}, + {Key: "$Type", Value: "Test$Bench"}, + {Key: "name", Value: "bench"}, + }) + dec := NewDecoder(r) + + b.ResetTimer() + for i := 0; i < b.N; i++ { + dec.Decode(raw) + } +} diff --git a/modelsdk/codec/codec_test.go b/modelsdk/codec/codec_test.go new file mode 100644 index 00000000..dc421592 --- /dev/null +++ b/modelsdk/codec/codec_test.go @@ -0,0 +1,295 @@ +package codec + +import ( + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/primitive" +) + +type stubElement struct { + element.Base +} + +// dirtyElement has a property that was modified. +type dirtyElement struct { + element.Base + name *property.Primitive[string] +} + +func newDirtyElement(raw bson.Raw) *dirtyElement { + e := &dirtyElement{ + name: property.NewPrimitive[string]("name", property.DecodeString), + } + e.SetRaw(raw) + e.name.Init(raw) + e.SetProperties([]element.Property{e.name}) + return e +} + +func TestRegistryLookup(t *testing.T) { + r := NewRegistry() + r.Register("Test$Foo", func() element.Element { return &stubElement{} }) + + factory, ok := r.Lookup("Test$Foo") + if !ok { + t.Fatal("should find registered type") + } + elem := factory() + if elem == nil { + t.Fatal("factory should return non-nil") + } + + _, ok = r.Lookup("Test$Unknown") + if ok { + t.Error("should not find unregistered type") + } +} + +func TestDecoderBasic(t *testing.T) { + r := NewRegistry() + r.Register("Test$Foo", func() element.Element { return &stubElement{} }) + + raw := mustMarshal(bson.D{ + {Key: "$ID", Value: primitive.Binary{Subtype: 4, Data: make([]byte, 16)}}, + {Key: "$Type", Value: "Test$Foo"}, + {Key: "name", Value: "hello"}, + }) + + dec := NewDecoder(r) + elem, err := dec.Decode(raw) + if err != nil { + t.Fatalf("Decode: %v", err) + } + if elem.TypeName() != "Test$Foo" { + t.Errorf("TypeName = %q", elem.TypeName()) + } + if elem.Raw() == nil { + t.Error("should retain raw bytes") + } +} + +func TestDecoderUnknownType(t *testing.T) { + r := NewRegistry() + raw := mustMarshal(bson.D{ + {Key: "$ID", Value: "some-id"}, + {Key: "$Type", Value: "Unknown$Type"}, + }) + dec := NewDecoder(r) + elem, err := dec.Decode(raw) + if err != nil { + t.Fatalf("Decode: %v", err) + } + if elem.TypeName() != "Unknown$Type" { + t.Errorf("TypeName = %q", elem.TypeName()) + } +} + +func TestDecoderMissingType(t *testing.T) { + r := NewRegistry() + raw := mustMarshal(bson.D{{Key: "$ID", Value: "some-id"}}) + dec := NewDecoder(r) + _, err := dec.Decode(raw) + if err == nil { + t.Error("should error on missing $Type") + } +} + +func mustMarshal(d bson.D) bson.Raw { + b, err := bson.Marshal(d) + if err != nil { + panic(err) + } + return bson.Raw(b) +} + +func TestEncoderPassthrough(t *testing.T) { + original := mustMarshal(bson.D{ + {Key: "$ID", Value: "test-id"}, + {Key: "$Type", Value: "Test$Foo"}, + {Key: "name", Value: "hello"}, + }) + + elem := &stubElement{} + elem.SetRaw(original) + elem.SetTypeName("Test$Foo") + elem.SetID("test-id") + + enc := &Encoder{} + out, err := enc.Encode(elem) + if err != nil { + t.Fatalf("Encode: %v", err) + } + if len(out) != len(original) { + t.Errorf("passthrough size mismatch: %d vs %d", len(out), len(original)) + } +} + +func TestEncoderNewElement(t *testing.T) { + elem := &stubElement{} + elem.SetTypeName("Test$New") + elem.SetID("new-id") + + enc := &Encoder{} + out, err := enc.Encode(elem) + if err != nil { + t.Fatalf("Encode: %v", err) + } + + // Verify it contains our fields + var doc bson.D + if err := bson.Unmarshal(out, &doc); err != nil { + t.Fatalf("Unmarshal: %v", err) + } + found := map[string]bool{} + for _, e := range doc { + found[e.Key] = true + } + if !found["$ID"] { + t.Error("missing $ID") + } + if !found["$Type"] { + t.Error("missing $Type") + } +} + +func TestEncoderChildDirty(t *testing.T) { + // child0 — clean, no property overrides; raw bytes should pass through. + child0 := &element.Base{} + child0.SetID("child-0") + child0.SetTypeName("Test$Child") + child0.SetRaw(mustMarshal(bson.D{ + {Key: "$ID", Value: "child-0"}, {Key: "$Type", Value: "Test$Child"}, {Key: "val", Value: "original-0"}, + })) + + // child1 — dirty: property was modified. + child1 := &element.Base{} + child1.SetID("child-1") + child1.SetTypeName("Test$Child") + child1.SetRaw(mustMarshal(bson.D{ + {Key: "$ID", Value: "child-1"}, {Key: "$Type", Value: "Test$Child"}, {Key: "val", Value: "original-1"}, + })) + nameProp := property.NewPrimitive[string]("val", property.DecodeString) + nameProp.Set("modified-1") + child1.SetProperties([]element.Property{nameProp}) + child1.MarkDirty(0) // simulate modification + + // Build parent with a PartList containing both children. + items := property.NewPartList[element.Element]("items") + items.AppendFromDecode(child0) + items.AppendFromDecode(child1) + + parent := &element.Base{} + parent.SetID("parent-id") + parent.SetTypeName("Test$Parent") + parent.SetRaw(mustMarshal(bson.D{ + {Key: "$ID", Value: "parent-id"}, + {Key: "$Type", Value: "Test$Parent"}, + {Key: "items", Value: bson.A{int32(3), + bson.D{{Key: "$ID", Value: "child-0"}, {Key: "$Type", Value: "Test$Child"}, {Key: "val", Value: "original-0"}}, + bson.D{{Key: "$ID", Value: "child-1"}, {Key: "$Type", Value: "Test$Child"}, {Key: "val", Value: "original-1"}}, + }}, + })) + parent.SetProperties([]element.Property{items}) + parent.MarkChildDirty() // parent is dirty because a child changed + + enc := &Encoder{} + out, err := enc.Encode(parent) + if err != nil { + t.Fatalf("Encode: %v", err) + } + + var doc bson.D + if err := bson.Unmarshal(out, &doc); err != nil { + t.Fatalf("Unmarshal: %v", err) + } + + foundItems := false + for _, e := range doc { + if e.Key != "items" { + continue + } + foundItems = true + arr := e.Value.(bson.A) + if len(arr) < 3 { + t.Fatalf("items has %d elements, want >= 3 (marker + 2 children)", len(arr)) + } + + // child0 (arr[1]) should retain "original-0". + child0Doc := arr[1].(bson.D) + for _, f := range child0Doc { + if f.Key == "val" && f.Value != "original-0" { + t.Errorf("child0.val = %v, want original-0", f.Value) + } + } + + // child1 (arr[2]) should have "modified-1". + child1Doc := arr[2].(bson.D) + for _, f := range child1Doc { + if f.Key == "val" && f.Value != "modified-1" { + t.Errorf("child1.val = %v, want modified-1", f.Value) + } + } + t.Log("child-dirty encoding verified") + } + if !foundItems { + t.Error("items field not found in encoded output") + } +} + +func TestEncoderDirtyRebuild(t *testing.T) { + // Create element with raw data, then modify a property. + original := mustMarshal(bson.D{ + {Key: "$ID", Value: "test-id"}, + {Key: "$Type", Value: "Test$Foo"}, + {Key: "name", Value: "original"}, + {Key: "unknownField", Value: "preserved"}, + }) + + elem := newDirtyElement(original) + elem.SetTypeName("Test$Foo") + elem.SetID("test-id") + + // Verify original value + if elem.name.Get() != "original" { + t.Fatalf("initial name = %q", elem.name.Get()) + } + + // Modify the property + elem.name.Set("modified") + elem.MarkDirty(0) + + enc := &Encoder{} + out, err := enc.Encode(elem) + if err != nil { + t.Fatalf("Encode: %v", err) + } + + // Decode and verify the output has the modified value + var doc bson.D + if err := bson.Unmarshal(out, &doc); err != nil { + t.Fatalf("Unmarshal: %v", err) + } + + fields := map[string]any{} + for _, e := range doc { + fields[e.Key] = e.Value + } + + // Modified field should have new value + if fields["name"] != "modified" { + t.Errorf("name = %v, want 'modified'", fields["name"]) + } + + // Unknown field should be preserved + if fields["unknownField"] != "preserved" { + t.Errorf("unknownField = %v, want 'preserved'", fields["unknownField"]) + } + + // Identity fields should be intact + if fields["$Type"] != "Test$Foo" { + t.Errorf("$Type = %v", fields["$Type"]) + } +} diff --git a/modelsdk/codec/decoder.go b/modelsdk/codec/decoder.go new file mode 100644 index 00000000..8a22903a --- /dev/null +++ b/modelsdk/codec/decoder.go @@ -0,0 +1,176 @@ +package codec + +import ( + "fmt" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/bsontype" +) + +// Decoder decodes a raw BSON document into an Element by dispatching on $Type. +type Decoder struct { + registry *TypeRegistry +} + +// NewDecoder returns a Decoder backed by the given registry. +func NewDecoder(r *TypeRegistry) *Decoder { + return &Decoder{registry: r} +} + +// RawInitializer is an optional interface that generated types can implement +// to populate their typed fields from the raw BSON bytes after construction. +type RawInitializer interface { + InitFromRaw(raw bson.Raw) +} + +// Decode parses raw and returns the appropriate Element. +// For types not found in the registry it returns a bare *element.Base that +// still carries the original raw bytes so the document round-trips safely. +func (d *Decoder) Decode(raw bson.Raw) (element.Element, error) { + typeName := decodeTypeName(raw) + if typeName == "" { + return nil, fmt.Errorf("missing $Type in BSON document") + } + + id := decodeID(raw) + + factory, ok := d.registry.Lookup(typeName) + if !ok { + // Unknown type — preserve raw bytes in a generic Base so the document + // can be round-tripped without data loss. + b := &element.Base{} + b.SetTypeName(typeName) + b.SetID(id) + b.SetRaw(raw) + return b, nil + } + + elem := factory() + + // All generated types embed element.Base, which exposes these setters. + if base, ok := elem.(interface{ SetTypeName(string) }); ok { + base.SetTypeName(typeName) + } + if base, ok := elem.(interface{ SetID(element.ID) }); ok { + base.SetID(id) + } + if base, ok := elem.(interface{ SetRaw(bson.Raw) }); ok { + base.SetRaw(raw) + } + + // Let the element parse its own typed fields if it knows how. + if ri, ok := elem.(RawInitializer); ok { + ri.InitFromRaw(raw) + } + + return elem, nil +} + +// decodeTypeName extracts the $Type string from a raw BSON document. +func decodeTypeName(raw bson.Raw) string { + val, err := raw.LookupErr("$Type") + if err != nil { + return "" + } + s, _ := val.StringValueOK() + return s +} + +// fieldAliases maps SDK property names to their BSON storage names where they +// differ. Mendix historically used "Form" for "Layout" and "Page". +var fieldAliases = map[string]string{ + "LayoutCall": "FormCall", + "PageSettings": "FormSettings", + "Layout": "Form", +} + +// DecodeChild decodes a single embedded document child from raw BSON by key. +// It uses DefaultRegistry to dispatch on $Type. Falls back to fieldAliases +// when the primary key is not found. +func DecodeChild(raw bson.Raw, key string) (element.Element, error) { + val, err := raw.LookupErr(key) + if err != nil { + if alias, ok := fieldAliases[key]; ok { + val, err = raw.LookupErr(alias) + } + if err != nil { + return nil, fmt.Errorf("key %q not found", key) + } + } + doc, ok := val.DocumentOK() + if !ok { + return nil, fmt.Errorf("key %q is not a document", key) + } + dec := NewDecoder(DefaultRegistry) + return dec.Decode(bson.Raw(doc)) +} + +// DecodeChildren decodes an array of embedded document children from raw BSON. +// It uses DefaultRegistry to dispatch on $Type for each element. +func DecodeChildren(raw bson.Raw, key string) ([]element.Element, error) { + val, err := raw.LookupErr(key) + if err != nil { + return nil, fmt.Errorf("key %q not found", key) + } + arr, ok := val.ArrayOK() + if !ok { + return nil, fmt.Errorf("key %q is not an array", key) + } + elems, err := arr.Elements() + if err != nil { + return nil, fmt.Errorf("key %q array elements: %w", key, err) + } + dec := NewDecoder(DefaultRegistry) + result := make([]element.Element, 0, len(elems)) + for _, el := range elems { + doc, ok := el.Value().DocumentOK() + if !ok { + continue // skip non-document elements + } + child, err := dec.Decode(bson.Raw(doc)) + if err != nil { + continue // skip elements that fail to decode + } + result = append(result, child) + } + return result, nil +} + +// decodeID extracts the $ID field, accepting either a UUID binary or a plain string. +func decodeID(raw bson.Raw) element.ID { + val, err := raw.LookupErr("$ID") + if err != nil { + return "" + } + return decodeIDValue(val) +} + +// decodeIDValue converts a BSON value (binary UUID or string) to an element.ID. +func decodeIDValue(val bson.RawValue) element.ID { + switch val.Type { + case bsontype.Binary: + _, data, ok := val.BinaryOK() + if ok && len(data) == 16 { + return element.ID(BinaryToUUID(data)) + } + case bsontype.String: + s, _ := val.StringValueOK() + return element.ID(s) + } + return "" +} + +// BinaryToUUID converts a 16-byte binary to a UUID string using Microsoft GUID +// format (little-endian first 3 groups) to match Mendix standard representation. +func BinaryToUUID(data []byte) string { + if len(data) != 16 { + return "" + } + return fmt.Sprintf("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + data[3], data[2], data[1], data[0], + data[5], data[4], + data[7], data[6], + data[8], data[9], + data[10], data[11], data[12], data[13], data[14], data[15]) +} diff --git a/modelsdk/codec/decoder_test.go b/modelsdk/codec/decoder_test.go new file mode 100644 index 00000000..27b670a1 --- /dev/null +++ b/modelsdk/codec/decoder_test.go @@ -0,0 +1,135 @@ +package codec + +import ( + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/primitive" +) + +// --- DecodeChild / DecodeChildren --- + +func TestDecodeChildMissingKey(t *testing.T) { + raw := mustMarshal(bson.D{{Key: "$Type", Value: "X"}}) + _, err := DecodeChild(raw, "noSuchKey") + if err == nil { + t.Error("expected error for missing key") + } +} + +func TestDecodeChildNotDocument(t *testing.T) { + raw := mustMarshal(bson.D{{Key: "child", Value: "stringNotDoc"}}) + _, err := DecodeChild(raw, "child") + if err == nil { + t.Error("expected error for non-document value") + } +} + +func TestDecodeChildValid(t *testing.T) { + raw := mustMarshal(bson.D{ + {Key: "child", Value: bson.D{ + {Key: "$ID", Value: "ch-1"}, + {Key: "$Type", Value: "Test$Child"}, + }}, + }) + elem, err := DecodeChild(raw, "child") + if err != nil { + t.Fatalf("DecodeChild: %v", err) + } + if elem.TypeName() != "Test$Child" { + t.Errorf("TypeName = %q", elem.TypeName()) + } +} + +func TestDecodeChildrenMissingKey(t *testing.T) { + raw := mustMarshal(bson.D{{Key: "$Type", Value: "X"}}) + _, err := DecodeChildren(raw, "noSuchKey") + if err == nil { + t.Error("expected error for missing key") + } +} + +func TestDecodeChildrenSkipsNonDocument(t *testing.T) { + raw := mustMarshal(bson.D{ + {Key: "items", Value: bson.A{ + int32(3), // Mendix marker — non-document, should be skipped + bson.D{{Key: "$ID", Value: "c1"}, {Key: "$Type", Value: "Test$C"}}, + }}, + }) + elems, err := DecodeChildren(raw, "items") + if err != nil { + t.Fatalf("DecodeChildren: %v", err) + } + if len(elems) != 1 { + t.Errorf("got %d elements, want 1 (marker skipped)", len(elems)) + } +} + +// --- decodeID --- + +func TestDecodeIDBinary(t *testing.T) { + data := make([]byte, 16) + for i := range data { + data[i] = byte(i + 0xa0) + } + raw := mustMarshal(bson.D{ + {Key: "$ID", Value: primitive.Binary{Subtype: 0, Data: data}}, + {Key: "$Type", Value: "X"}, + }) + id := decodeID(raw) + if id == "" { + t.Error("decodeID returned empty for binary $ID") + } + t.Logf("decoded ID: %s", id) +} + +func TestDecodeIDString(t *testing.T) { + raw := mustMarshal(bson.D{ + {Key: "$ID", Value: "some-string-id"}, + {Key: "$Type", Value: "X"}, + }) + id := decodeID(raw) + if id != "some-string-id" { + t.Errorf("decodeID = %q, want some-string-id", id) + } +} + +func TestDecodeIDMissing(t *testing.T) { + raw := mustMarshal(bson.D{{Key: "$Type", Value: "X"}}) + id := decodeID(raw) + if id != "" { + t.Errorf("decodeID should be empty for missing $ID, got %q", id) + } +} + +// --- Decoder with RawInitializer --- + +type initTracker struct { + element.Base + initialized bool +} + +func (it *initTracker) InitFromRaw(raw bson.Raw) { + it.initialized = true +} + +func TestDecoderCallsRawInitializer(t *testing.T) { + r := NewRegistry() + r.Register("Test$Init", func() element.Element { return &initTracker{} }) + + raw := mustMarshal(bson.D{ + {Key: "$ID", Value: "id-1"}, + {Key: "$Type", Value: "Test$Init"}, + }) + + dec := NewDecoder(r) + elem, err := dec.Decode(raw) + if err != nil { + t.Fatalf("Decode: %v", err) + } + it := elem.(*initTracker) + if !it.initialized { + t.Error("InitFromRaw was not called") + } +} diff --git a/modelsdk/codec/encoder.go b/modelsdk/codec/encoder.go new file mode 100644 index 00000000..08cf1ad2 --- /dev/null +++ b/modelsdk/codec/encoder.go @@ -0,0 +1,163 @@ +package codec + +import ( + "fmt" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/mpr" + "go.mongodb.org/mongo-driver/bson" +) + +// Encoder serializes Element trees back to BSON bytes. +type Encoder struct{} + +// Encode serializes an element to []byte. +// Clean elements passthrough raw bytes unchanged. +// Dirty elements rebuild: start from raw fields, overlay dirty property values, +// recursively encode child elements. +func (e *Encoder) Encode(elem element.Element) ([]byte, error) { + raw := elem.Raw() + if raw != nil && !elem.IsDirty() { + return []byte(raw), nil + } + + doc, err := e.buildDoc(elem) + if err != nil { + return nil, err + } + return bson.Marshal(doc) +} + +// buildDoc constructs a bson.D for an element, merging raw fields with dirty overrides. +func (e *Encoder) buildDoc(elem element.Element) (bson.D, error) { + // Start from raw if available (preserves unknown fields). + var doc bson.D + if raw := elem.Raw(); raw != nil { + if err := bson.Unmarshal(raw, &doc); err != nil { + return nil, fmt.Errorf("unmarshal raw for %s: %w", elem.TypeName(), err) + } + } else { + // New element — start with identity fields. + doc = bson.D{ + {Key: "$ID", Value: idToBinarySubtype0(elem.ID())}, + {Key: "$Type", Value: elem.TypeName()}, + } + } + + // Overlay dirty properties. + for _, prop := range elem.Properties() { + wp, ok := prop.(element.WritableProperty) + if !ok { + continue + } + + key := prop.Name() + + // Handle child properties (Part) — recursive encode. + if cp, ok := prop.(element.ChildProperty); ok { + if !wp.Dirty() { + continue + } + child := cp.ChildElement() + if child != nil { + childDoc, err := e.buildDoc(child) + if err != nil { + return nil, err + } + doc = setField(doc, key, childDoc) + } else { + doc = setField(doc, key, nil) + } + continue + } + + // Handle child list properties (PartList) — three branches: + // 1. Self-dirty: list was modified (Append/Remove) → full rebuild. + // 2. Child-dirty: list unchanged but a child was modified → selective rebuild. + // 3. Completely clean → skip (don't touch the raw field). + if clp, ok := prop.(element.ChildListProperty); ok { + if wp.Dirty() { + // Branch 1: full rebuild — all children re-encoded. + children := clp.ChildElements() + arr := bson.A{int32(3)} + for _, child := range children { + childDoc, err := e.buildDoc(child) + if err != nil { + return nil, err + } + arr = append(arr, childDoc) + } + doc = setField(doc, key, arr) + } else if anyChildDirty(clp) { + // Branch 2: selective rebuild — dirty children re-encoded, clean ones pass through raw bytes. + children := clp.ChildElements() + arr := bson.A{int32(3)} + for _, child := range children { + if child.IsDirty() { + childDoc, err := e.buildDoc(child) + if err != nil { + return nil, err + } + arr = append(arr, childDoc) + } else { + arr = append(arr, bson.Raw(child.Raw())) + } + } + doc = setField(doc, key, arr) + } + // Branch 3: completely clean — leave raw field untouched. + continue + } + + // Scalar/Enum/Ref properties — only process if dirty. + if !wp.Dirty() { + continue + } + + // Scalar/Enum/Ref properties — use BSONValue directly. + val := wp.BSONValue() + // Convert element.ID to binary UUID for BSON compatibility. + if id, ok := val.(element.ID); ok && id != "" { + doc = setField(doc, key, idToBinary(id)) + } else { + doc = setField(doc, key, val) + } + } + + return doc, nil +} + +// anyChildDirty reports whether any element in the ChildListProperty is dirty. +func anyChildDirty(clp element.ChildListProperty) bool { + for _, child := range clp.ChildElements() { + if child.IsDirty() { + return true + } + } + return false +} + +// setField replaces or appends a field in a bson.D. +func setField(doc bson.D, key string, val any) bson.D { + for i, e := range doc { + if e.Key == key { + doc[i].Value = val + return doc + } + } + return append(doc, bson.E{Key: key, Value: val}) +} + +// idToBinarySubtype0 converts a UUID string to BSON Binary subtype 0 +// using the Mendix byte-swap convention (via sdk/mpr.IDToBsonBinary). +func idToBinarySubtype0(id element.ID) any { + if id == "" { + return id + } + return mpr.IDToBsonBinary(string(id)) +} + +// idToBinary converts a UUID string to Mendix BSON Binary format. +func idToBinary(id element.ID) any { + return idToBinarySubtype0(id) +} diff --git a/modelsdk/codec/encoder_test.go b/modelsdk/codec/encoder_test.go new file mode 100644 index 00000000..a040034f --- /dev/null +++ b/modelsdk/codec/encoder_test.go @@ -0,0 +1,131 @@ +package codec + +import ( + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +func TestEncoderNewElementHasBinaryID(t *testing.T) { + elem := &element.Base{} + elem.SetTypeName("Test$New") + elem.SetID("aaaabbbb-cccc-dddd-eeee-ffffffffffff") + elem.MarkDirty(63) // new element + + enc := &Encoder{} + out, err := enc.Encode(elem) + if err != nil { + t.Fatalf("Encode: %v", err) + } + + raw := bson.Raw(out) + idVal, _ := raw.LookupErr("$ID") + if idVal.Type.String() != "binary" { + t.Errorf("$ID type = %s, want binary", idVal.Type) + } +} + +func TestEncoderPreservesUnknownFields(t *testing.T) { + original := mustMarshal(bson.D{ + {Key: "$ID", Value: "id-1"}, + {Key: "$Type", Value: "Test$X"}, + {Key: "known", Value: "v1"}, + {Key: "unknown_field", Value: int32(42)}, + {Key: "another_unknown", Value: true}, + }) + + knownProp := property.NewPrimitive[string]("known", property.DecodeString) + knownProp.Init(original) + + elem := &element.Base{} + elem.SetID("id-1") + elem.SetTypeName("Test$X") + elem.SetRaw(original) + elem.SetProperties([]element.Property{knownProp}) + + // Modify the known property + knownProp.Bind(elem, 0) + knownProp.Set("v2") + + enc := &Encoder{} + out, err := enc.Encode(elem) + if err != nil { + t.Fatalf("Encode: %v", err) + } + + var doc bson.D + bson.Unmarshal(out, &doc) + fields := map[string]any{} + for _, e := range doc { + fields[e.Key] = e.Value + } + + if fields["known"] != "v2" { + t.Errorf("known = %v, want v2", fields["known"]) + } + if fields["unknown_field"] != int32(42) { + t.Errorf("unknown_field = %v, want 42", fields["unknown_field"]) + } + if fields["another_unknown"] != true { + t.Errorf("another_unknown = %v, want true", fields["another_unknown"]) + } +} + +func TestEncoderPartDirty(t *testing.T) { + parentRaw := mustMarshal(bson.D{ + {Key: "$ID", Value: "p-1"}, + {Key: "$Type", Value: "Test$P"}, + {Key: "child", Value: bson.D{ + {Key: "$ID", Value: "c-1"}, + {Key: "$Type", Value: "Test$C"}, + {Key: "val", Value: "old"}, + }}, + }) + + child := &element.Base{} + child.SetID("c-1") + child.SetTypeName("Test$C") + child.SetRaw(mustMarshal(bson.D{ + {Key: "$ID", Value: "c-1"}, + {Key: "$Type", Value: "Test$C"}, + {Key: "val", Value: "old"}, + })) + valProp := property.NewPrimitive[string]("val", property.DecodeString) + valProp.Init(child.Raw()) + valProp.Bind(child, 0) + valProp.Set("new") + child.SetProperties([]element.Property{valProp}) + + parent := &element.Base{} + parent.SetID("p-1") + parent.SetTypeName("Test$P") + parent.SetRaw(parentRaw) + + childPart := property.NewPart[element.Element]("child") + childPart.Bind(parent, 0) + parent.SetProperties([]element.Property{childPart}) + + // Mark the Part as dirty by setting the child + childPart.Set(child) + + enc := &Encoder{} + out, err := enc.Encode(parent) + if err != nil { + t.Fatalf("Encode: %v", err) + } + + var doc bson.D + bson.Unmarshal(out, &doc) + for _, e := range doc { + if e.Key == "child" { + childDoc := e.Value.(bson.D) + for _, f := range childDoc { + if f.Key == "val" && f.Value != "new" { + t.Errorf("child.val = %v, want new", f.Value) + } + } + } + } +} diff --git a/modelsdk/codec/interfaces.go b/modelsdk/codec/interfaces.go new file mode 100644 index 00000000..f184f242 --- /dev/null +++ b/modelsdk/codec/interfaces.go @@ -0,0 +1,29 @@ +package codec + +import ( + "github.com/mendixlabs/mxcli/modelsdk/element" + "go.mongodb.org/mongo-driver/bson" +) + +// UnitReader provides read-only access to MPR units. +type UnitReader interface { + ListUnits() []UnitInfo + LoadUnit(id element.ID) (bson.Raw, error) + Path() string + IsWritable() bool +} + +// UnitWriter provides write access to MPR units. +type UnitWriter interface { + InsertUnit(unitID, containerID, containmentName, unitType string, contents []byte) error + DeleteUnit(unitID string) error + DeleteChildUnits(parentID string) error + SaveUnit(id element.ID, data []byte) error + FlushUnits(units map[element.ID][]byte) error +} + +// Compile-time interface satisfaction checks. +var ( + _ UnitReader = (*Store)(nil) + _ UnitWriter = (*Store)(nil) +) diff --git a/modelsdk/codec/refregistry.go b/modelsdk/codec/refregistry.go new file mode 100644 index 00000000..cd971d25 --- /dev/null +++ b/modelsdk/codec/refregistry.go @@ -0,0 +1,57 @@ +package codec + +// RefKind identifies the kind of reference property. +type RefKind string + +const ( + RefByName RefKind = "byname" + RefByNameList RefKind = "bynamelist" + RefById RefKind = "byid" +) + +// RefMeta describes a single reference property on a generated type. +type RefMeta struct { + Prop string // BSON key (e.g. "Entity", "ParentPointer") + Kind RefKind // byname, bynamelist, or byid + Target string // TargetType for ByNameRef (e.g. "DomainModels$Entity"); empty for ByIdRef +} + +// RefRegistry stores reference metadata for all generated types. +type RefRegistry struct { + refs map[string][]RefMeta // structureTypeName -> reference properties +} + +// DefaultRefRegistry is the package-level registry populated by generated init() functions. +var DefaultRefRegistry = NewRefRegistry() + +// NewRefRegistry returns an empty RefRegistry. +func NewRefRegistry() *RefRegistry { + return &RefRegistry{refs: map[string][]RefMeta{}} +} + +// RegisterRefs records reference properties for a type. +func (r *RefRegistry) RegisterRefs(typeName string, refs []RefMeta) { + r.refs[typeName] = refs +} + +// Refs returns the reference properties for a type. +func (r *RefRegistry) Refs(typeName string) []RefMeta { + return r.refs[typeName] +} + +// AllTargetTypes returns all unique ByNameRef target types across all registered types. +func (r *RefRegistry) AllTargetTypes() []string { + set := map[string]bool{} + for _, refs := range r.refs { + for _, ref := range refs { + if ref.Target != "" { + set[ref.Target] = true + } + } + } + result := make([]string, 0, len(set)) + for t := range set { + result = append(result, t) + } + return result +} diff --git a/modelsdk/codec/registry.go b/modelsdk/codec/registry.go new file mode 100644 index 00000000..5e156595 --- /dev/null +++ b/modelsdk/codec/registry.go @@ -0,0 +1,52 @@ +package codec + +import ( + "sync" + + "github.com/mendixlabs/mxcli/modelsdk/element" +) + +// TypeRegistry maps BSON $Type strings to element factory functions. +type TypeRegistry struct { + mu sync.RWMutex + factories map[string]func() element.Element +} + +// NewRegistry returns an empty TypeRegistry. +func NewRegistry() *TypeRegistry { + return &TypeRegistry{factories: map[string]func() element.Element{}} +} + +// Register adds or replaces the factory for the given typeName. +func (r *TypeRegistry) Register(typeName string, factory func() element.Element) { + r.mu.Lock() + r.factories[typeName] = factory + r.mu.Unlock() +} + +// Lookup returns the factory for typeName, and whether it was found. +func (r *TypeRegistry) Lookup(typeName string) (func() element.Element, bool) { + r.mu.RLock() + f, ok := r.factories[typeName] + r.mu.RUnlock() + return f, ok +} + +// RegisterAlias registers storageName as an alias for qualifiedName. +// When the decoder encounters storageName in $Type, it uses the factory +// registered for qualifiedName. +func (r *TypeRegistry) RegisterAlias(storageName, qualifiedName string) { + r.mu.RLock() + f, ok := r.factories[qualifiedName] + r.mu.RUnlock() + if ok { + r.Register(storageName, f) + } +} + +// DefaultRegistry is the package-level registry used by generated types. +var DefaultRegistry = NewRegistry() + +// No runtime aliases needed — all storage name mappings are handled at +// codegen time via dual registration in gen/*/types.go init() functions. +// See cmd/modelsdk-codegen/main.go storageAliases and propertyKeyOverrides. diff --git a/modelsdk/codec/resolver.go b/modelsdk/codec/resolver.go new file mode 100644 index 00000000..f71bae83 --- /dev/null +++ b/modelsdk/codec/resolver.go @@ -0,0 +1,313 @@ +// SPDX-License-Identifier: Apache-2.0 + +package codec + +import ( + "fmt" + "strings" + + "github.com/mendixlabs/mxcli/modelsdk/mpr" + "go.mongodb.org/mongo-driver/bson" +) + +// TypeResolver maps human-friendly type aliases to BSON $Type prefixes +// and provides type-aware unit lookups that mpr.Reader shouldn't own. +type TypeResolver struct { + prefixes map[string]string +} + +// NewTypeResolver returns a TypeResolver pre-populated with all known Mendix type mappings. +func NewTypeResolver() *TypeResolver { + return &TypeResolver{ + prefixes: map[string]string{ + "page": "Forms$Page", + "entity": "DomainModels$Entity", + "association": "DomainModels$Association", + "microflow": "Microflows$Microflow", + "nanoflow": "Microflows$Nanoflow", + "enumeration": "Enumerations$Enumeration", + "snippet": "Forms$Snippet", + "layout": "Forms$Layout", + "constant": "Constants$Constant", + "workflow": "Workflows$Workflow", + "imagecollection": "Images$ImageCollection", + "javaaction": "JavaActions$JavaAction", + "javascriptaction": "JavaScriptActions$JavaScriptAction", + }, + } +} + +// RegisterPrefix adds or overrides a type alias mapping. +func (r *TypeResolver) RegisterPrefix(alias, bsonType string) { + r.prefixes[strings.ToLower(alias)] = bsonType +} + +// BSONType returns the BSON $Type prefix for a given alias. +func (r *TypeResolver) BSONType(alias string) (string, bool) { + t, ok := r.prefixes[strings.ToLower(alias)] + return t, ok +} + +// GetRawUnitByName finds a unit by human-friendly type alias and qualified name. +// For entities and associations, searches within domain model units. +func (r *TypeResolver) GetRawUnitByName(reader *mpr.Reader, objectType, qualifiedName string) (*mpr.RawUnitInfo, error) { + lower := strings.ToLower(objectType) + + // Entities and associations are nested inside DomainModel units + switch lower { + case "entity": + return r.getRawEntityByName(reader, qualifiedName) + case "association": + return r.getRawAssociationByName(reader, qualifiedName) + } + + typePrefix, ok := r.prefixes[lower] + if !ok { + return nil, fmt.Errorf("unsupported object type: %s", objectType) + } + + units, err := reader.ListUnitsByType(typePrefix) + if err != nil { + return nil, err + } + + modules, err := reader.ListModules() + if err != nil { + return nil, err + } + moduleMap := make(map[string]string) + for _, m := range modules { + moduleMap[string(m.ID)] = m.Name + } + containerParent, err := reader.BuildContainerParent() + if err != nil { + return nil, err + } + + for _, u := range units { + var raw map[string]any + if err := bson.Unmarshal(u.Contents, &raw); err != nil { + continue + } + name, _ := raw["Name"].(string) + moduleName := mpr.ResolveModuleName(u.ContainerID, moduleMap, containerParent) + var fullName string + if moduleName != "" { + fullName = moduleName + "." + name + } else { + fullName = name + } + if fullName == qualifiedName { + return &mpr.RawUnitInfo{ + ID: u.ID, QualifiedName: fullName, + Type: u.Type, ModuleName: moduleName, + Contents: u.Contents, + }, nil + } + } + return nil, fmt.Errorf("%s not found: %s", objectType, qualifiedName) +} + +// ListRawUnits returns all units of a given type alias. +func (r *TypeResolver) ListRawUnits(reader *mpr.Reader, objectType string) ([]*mpr.RawUnitInfo, error) { + typePrefix := "" + if objectType != "" { + var ok bool + typePrefix, ok = r.prefixes[strings.ToLower(objectType)] + if !ok { + return nil, fmt.Errorf("unsupported object type: %s", objectType) + } + } + + units, err := reader.ListUnitsByType(typePrefix) + if err != nil { + return nil, err + } + + modules, err := reader.ListModules() + if err != nil { + return nil, err + } + moduleMap := make(map[string]string) + for _, m := range modules { + moduleMap[string(m.ID)] = m.Name + } + containerParent, err := reader.BuildContainerParent() + if err != nil { + return nil, err + } + + var result []*mpr.RawUnitInfo + for _, u := range units { + var raw map[string]any + if err := bson.Unmarshal(u.Contents, &raw); err != nil { + continue + } + name, _ := raw["Name"].(string) + moduleName := mpr.ResolveModuleName(u.ContainerID, moduleMap, containerParent) + fullName := name + if moduleName != "" { + fullName = moduleName + "." + name + } + result = append(result, &mpr.RawUnitInfo{ + ID: u.ID, QualifiedName: fullName, + Type: u.Type, ModuleName: moduleName, + Contents: u.Contents, + }) + } + return result, nil +} + +// getRawEntityByName finds an entity within domain models. +func (r *TypeResolver) getRawEntityByName(reader *mpr.Reader, qualifiedName string) (*mpr.RawUnitInfo, error) { + parts := strings.Split(qualifiedName, ".") + if len(parts) != 2 { + return nil, fmt.Errorf("invalid entity name: %s (expected Module.Entity)", qualifiedName) + } + targetModule := parts[0] + targetEntity := parts[1] + + units, err := reader.ListUnitsByType("DomainModels$DomainModel") + if err != nil { + return nil, err + } + + modules, err := reader.ListModules() + if err != nil { + return nil, err + } + moduleMap := make(map[string]string) + for _, m := range modules { + moduleMap[string(m.ID)] = m.Name + } + + for _, u := range units { + moduleName := moduleMap[u.ContainerID] + if moduleName != targetModule { + continue + } + + var rawD bson.D + if err := bson.Unmarshal(u.Contents, &rawD); err != nil { + continue + } + + var entitiesVal any + for _, field := range rawD { + if field.Key == "Entities" { + entitiesVal = field.Value + break + } + } + + entities, ok := entitiesVal.(bson.A) + if !ok { + continue + } + + // Skip version marker (first element is int32 array type indicator) + for i := 1; i < len(entities); i++ { + entity, ok := entities[i].(bson.D) + if !ok { + continue + } + + for _, field := range entity { + if field.Key == "Name" { + if name, ok := field.Value.(string); ok && name == targetEntity { + entityBytes, err := bson.Marshal(entity) + if err != nil { + return nil, err + } + return &mpr.RawUnitInfo{ + ID: u.ID, + QualifiedName: qualifiedName, + Type: "DomainModels$Entity", + ModuleName: moduleName, + Contents: entityBytes, + }, nil + } + } + } + } + } + + return nil, fmt.Errorf("entity not found: %s", qualifiedName) +} + +// getRawAssociationByName finds an association within domain models. +func (r *TypeResolver) getRawAssociationByName(reader *mpr.Reader, qualifiedName string) (*mpr.RawUnitInfo, error) { + parts := strings.Split(qualifiedName, ".") + if len(parts) != 2 { + return nil, fmt.Errorf("invalid association name: %s (expected Module.AssociationName)", qualifiedName) + } + targetModule := parts[0] + targetAssoc := parts[1] + + units, err := reader.ListUnitsByType("DomainModels$DomainModel") + if err != nil { + return nil, err + } + + modules, err := reader.ListModules() + if err != nil { + return nil, err + } + moduleMap := make(map[string]string) + for _, m := range modules { + moduleMap[string(m.ID)] = m.Name + } + + for _, u := range units { + moduleName := moduleMap[u.ContainerID] + if moduleName != targetModule { + continue + } + + var rawD bson.D + if err := bson.Unmarshal(u.Contents, &rawD); err != nil { + continue + } + + var assocsVal any + for _, field := range rawD { + if field.Key == "Associations" { + assocsVal = field.Value + break + } + } + + assocs, ok := assocsVal.(bson.A) + if !ok { + continue + } + + // Skip version marker (first element is int32 array type indicator) + for i := 1; i < len(assocs); i++ { + assoc, ok := assocs[i].(bson.D) + if !ok { + continue + } + + for _, field := range assoc { + if field.Key == "Name" { + if name, ok := field.Value.(string); ok && name == targetAssoc { + assocBytes, err := bson.Marshal(assoc) + if err != nil { + return nil, err + } + return &mpr.RawUnitInfo{ + ID: u.ID, + QualifiedName: qualifiedName, + Type: "DomainModels$Association", + ModuleName: moduleName, + Contents: assocBytes, + }, nil + } + } + } + } + } + + return nil, fmt.Errorf("association not found: %s", qualifiedName) +} diff --git a/modelsdk/codec/roundtrip_test.go b/modelsdk/codec/roundtrip_test.go new file mode 100644 index 00000000..8a0eb257 --- /dev/null +++ b/modelsdk/codec/roundtrip_test.go @@ -0,0 +1,141 @@ +package codec + +import ( + "bytes" + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/primitive" +) + +// TestFullRoundtripClean verifies decode → encode passthrough is byte-identical. +func TestFullRoundtripClean(t *testing.T) { + r := NewRegistry() + r.Register("Test$RT", func() element.Element { + o := &element.Base{} + p := property.NewPrimitive[string]("Name", property.DecodeString) + p.Bind(o, 0) + o.SetProperties([]element.Property{p}) + return o + }) + + original := mustMarshal(bson.D{ + {Key: "$ID", Value: primitive.Binary{Subtype: 0, Data: make([]byte, 16)}}, + {Key: "$Type", Value: "Test$RT"}, + {Key: "Name", Value: "hello"}, + {Key: "Extra", Value: int32(99)}, + }) + + dec := NewDecoder(r) + elem, err := dec.Decode(original) + if err != nil { + t.Fatalf("Decode: %v", err) + } + + // Element should be clean (not dirty) + if elem.IsDirty() { + t.Error("decoded element should not be dirty") + } + + enc := &Encoder{} + out, err := enc.Encode(elem) + if err != nil { + t.Fatalf("Encode: %v", err) + } + + if !bytes.Equal(out, []byte(original)) { + t.Errorf("roundtrip mismatch: %d bytes in, %d bytes out", len(original), len(out)) + } +} + +// TestFullRoundtripDirty verifies decode → modify → encode preserves unmodified fields. +func TestFullRoundtripDirty(t *testing.T) { + r := NewRegistry() + r.Register("Test$RTD", func() element.Element { + o := &element.Base{} + p := property.NewPrimitive[string]("Name", property.DecodeString) + p.Bind(o, 0) + o.SetProperties([]element.Property{p}) + return o + }) + + original := mustMarshal(bson.D{ + {Key: "$ID", Value: primitive.Binary{Subtype: 0, Data: make([]byte, 16)}}, + {Key: "$Type", Value: "Test$RTD"}, + {Key: "Name", Value: "original"}, + {Key: "Unknown", Value: "preserved"}, + }) + + dec := NewDecoder(r) + elem, err := dec.Decode(original) + if err != nil { + t.Fatalf("Decode: %v", err) + } + + // Modify the Name property + props := elem.Properties() + if len(props) == 0 { + t.Fatal("no properties") + } + prim := props[0].(*property.Primitive[string]) + prim.Init(elem.Raw()) + if prim.Get() != "original" { + t.Fatalf("Name = %q, want original", prim.Get()) + } + prim.Set("modified") + + enc := &Encoder{} + out, err := enc.Encode(elem) + if err != nil { + t.Fatalf("Encode: %v", err) + } + + // Verify output + var doc bson.D + bson.Unmarshal(out, &doc) + fields := map[string]any{} + for _, e := range doc { + fields[e.Key] = e.Value + } + + if fields["Name"] != "modified" { + t.Errorf("Name = %v, want modified", fields["Name"]) + } + if fields["Unknown"] != "preserved" { + t.Errorf("Unknown = %v, want preserved", fields["Unknown"]) + } + if fields["$Type"] != "Test$RTD" { + t.Errorf("$Type = %v", fields["$Type"]) + } +} + +// TestDecodeEncodeWithChildren tests parent+children roundtrip. +func TestDecodeEncodeWithChildren(t *testing.T) { + original := mustMarshal(bson.D{ + {Key: "$ID", Value: primitive.Binary{Subtype: 0, Data: make([]byte, 16)}}, + {Key: "$Type", Value: "Test$Parent"}, + {Key: "Items", Value: bson.A{int32(3), + bson.D{{Key: "$ID", Value: "c1"}, {Key: "$Type", Value: "Test$C1"}, {Key: "V", Value: "v1"}}, + bson.D{{Key: "$ID", Value: "c2"}, {Key: "$Type", Value: "Test$C2"}, {Key: "V", Value: "v2"}}, + }}, + }) + + // No registry — children decode as *element.Base + dec := NewDecoder(NewRegistry()) + elem, err := dec.Decode(original) + if err != nil { + t.Fatalf("Decode: %v", err) + } + + // Clean passthrough + enc := &Encoder{} + out, err := enc.Encode(elem) + if err != nil { + t.Fatalf("Encode: %v", err) + } + if !bytes.Equal(out, []byte(original)) { + t.Error("clean roundtrip should be byte-identical") + } +} diff --git a/modelsdk/codec/store.go b/modelsdk/codec/store.go new file mode 100644 index 00000000..4a17e1ef --- /dev/null +++ b/modelsdk/codec/store.go @@ -0,0 +1,201 @@ +package codec + +import ( + "fmt" + "log" + "time" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/mpr" + "github.com/mendixlabs/mxcli/modelsdk/mpr/version" + "go.mongodb.org/mongo-driver/bson" +) + +// UnitInfo holds basic metadata for a unit in the MPR store. +type UnitInfo struct { + ID element.ID + ContainerID element.ID + Type string // BSON $Type (e.g. "Microflows$Microflow") + Name string // BSON Name field (e.g. "MyModule" for modules) +} + +// Store wraps mpr.Reader (read-only) or mpr.Writer (read-write) and exposes +// unit-level BSON access for the codec layer. +type Store struct { + reader *mpr.Reader + writer *mpr.Writer // nil for read-only + writable bool +} + +// Open opens the MPR file at path for reading. +func Open(path string) (*Store, error) { + r, err := mpr.Open(path) + if err != nil { + return nil, fmt.Errorf("open MPR: %w", err) + } + return &Store{reader: r}, nil +} + +// OpenForWriting opens the MPR file at path for reading and writing. +func OpenForWriting(path string) (*Store, error) { + w, err := mpr.NewWriter(path) + if err != nil { + return nil, fmt.Errorf("open MPR for writing: %w", err) + } + return &Store{ + reader: w.Reader(), + writer: w, + writable: true, + }, nil +} + +// Close releases resources held by the underlying Reader/Writer. +func (s *Store) Close() error { + if s.writer != nil { + return s.writer.Close() + } + return s.reader.Close() +} + +// IsWritable returns true if the store was opened for writing. +func (s *Store) IsWritable() bool { return s.writable } + +// ListUnits returns metadata for every unit in the project. +func (s *Store) ListUnits() []UnitInfo { + listStart := time.Now() + refs, err := s.reader.ListUnitsByType("") + if err != nil { + return nil + } + units := make([]UnitInfo, 0, len(refs)) + for _, ref := range refs { + name := "" + // Use Contents from ListUnitsByType when available to avoid N+1 re-reads. + raw := ref.Contents + if len(raw) == 0 { + raw, _ = s.reader.GetRawUnitBytes(ref.ID) + } + if len(raw) > 0 { + if val, err := bson.Raw(raw).LookupErr("Name"); err == nil { + name, _ = val.StringValueOK() + } + } + units = append(units, UnitInfo{ + ID: element.ID(ref.ID), + ContainerID: element.ID(ref.ContainerID), + Type: ref.Type, + Name: name, + }) + } + log.Printf("[perf] Store.ListUnits: %s (units=%d)", time.Since(listStart), len(units)) + return units +} + +// LoadUnit fetches the raw BSON document for the unit identified by id. +func (s *Store) LoadUnit(id element.ID) (bson.Raw, error) { + // Use GetRawUnitBytes to get the original BSON bytes directly. + // Do NOT use GetRawUnit (returns map[string]any) + bson.Marshal — + // that round-trip corrupts Binary $ID fields into strings. + b, err := s.reader.GetRawUnitBytes(string(id)) + if err != nil { + return nil, fmt.Errorf("load unit %s: %w", id, err) + } + return bson.Raw(b), nil +} + +// SaveUnit writes a unit's BSON bytes back to the MPR. +// Must have been opened with OpenForWriting. +func (s *Store) SaveUnit(id element.ID, data []byte) error { + if !s.writable { + return fmt.Errorf("store is read-only — use OpenForWriting") + } + wt, err := s.writer.BeginWriteTransaction() + if err != nil { + return fmt.Errorf("begin write transaction: %w", err) + } + if err := wt.WriteUnit(string(id), data); err != nil { + wt.Rollback() + return fmt.Errorf("write unit %s: %w", id, err) + } + if err := wt.Commit(); err != nil { + return fmt.Errorf("commit unit %s: %w", id, err) + } + return nil +} + +// Path returns the file path of the underlying MPR. +func (s *Store) Path() string { return s.reader.Path() } + +// GetProjectRootID returns the ID of the project root unit. +func (s *Store) GetProjectRootID() (string, error) { + return s.reader.GetProjectRootID() +} + +// GetModuleByName retrieves a module by name from the underlying MPR reader. +func (s *Store) GetModuleByName(name string) (*mpr.ModuleInfo, error) { + return s.reader.GetModuleByName(name) +} + +// UpdateUnitContainer changes the container (parent) of a unit. +// Must have been opened with OpenForWriting. +func (s *Store) UpdateUnitContainer(unitID, newContainerID string) error { + if !s.writable { + return fmt.Errorf("store is read-only — use OpenForWriting") + } + return s.writer.UpdateUnitContainer(unitID, newContainerID) +} + +// InvalidateReaderCache clears the underlying reader's cached data. +func (s *Store) InvalidateReaderCache() { + s.reader.InvalidateCache() +} + +// ProjectVersion returns the Mendix version of the project. +func (s *Store) ProjectVersion() *version.ProjectVersion { + return s.reader.ProjectVersion() +} + +// DeleteChildUnits recursively deletes all units whose ContainerID matches parentID. +func (s *Store) DeleteChildUnits(parentID string) error { + if !s.writable { + return fmt.Errorf("store is read-only — use OpenForWriting") + } + return s.writer.DeleteChildUnits(parentID) +} + +// InsertUnit creates a new unit in the MPR. +func (s *Store) InsertUnit(unitID, containerID, containmentName, unitType string, contents []byte) error { + if !s.writable { + return fmt.Errorf("store is read-only — use OpenForWriting") + } + return s.writer.InsertUnit(unitID, containerID, containmentName, unitType, contents) +} + +// DeleteUnit removes a unit from the MPR. +func (s *Store) DeleteUnit(unitID string) error { + if !s.writable { + return fmt.Errorf("store is read-only — use OpenForWriting") + } + return s.writer.DeleteUnit(unitID) +} + +// FlushUnits saves multiple units atomically in a single transaction. +func (s *Store) FlushUnits(units map[element.ID][]byte) error { + if !s.writable { + return fmt.Errorf("store is read-only — use OpenForWriting") + } + wt, err := s.writer.BeginWriteTransaction() + if err != nil { + return fmt.Errorf("begin write transaction: %w", err) + } + for id, data := range units { + if err := wt.WriteUnit(string(id), data); err != nil { + wt.Rollback() + return fmt.Errorf("write unit %s: %w", id, err) + } + } + if err := wt.Commit(); err != nil { + return fmt.Errorf("commit: %w", err) + } + return nil +} diff --git a/modelsdk/dirty_chain_test.go b/modelsdk/dirty_chain_test.go new file mode 100644 index 00000000..05b5e152 --- /dev/null +++ b/modelsdk/dirty_chain_test.go @@ -0,0 +1,182 @@ +package modelsdk_test + +import ( + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" +) + +// TestDirtyChainPropagation verifies the full 3-layer dirty propagation: +// Property.Set → Base.MarkDirty(bit) → container.MarkChildDirty → root +func TestDirtyChainPropagation(t *testing.T) { + // Build: root → mid → leaf, each with a Primitive property bound + root := &element.Base{} + rootProp := property.NewPrimitive[string]("RootName", property.DecodeString) + rootProp.Bind(root, 0) + root.SetProperties([]element.Property{rootProp}) + + mid := &element.Base{} + mid.SetContainer(root) + midProp := property.NewPrimitive[string]("MidName", property.DecodeString) + midProp.Bind(mid, 0) + mid.SetProperties([]element.Property{midProp}) + + leaf := &element.Base{} + leaf.SetContainer(mid) + leafProp := property.NewPrimitive[string]("LeafName", property.DecodeString) + leafProp.Bind(leaf, 0) + leaf.SetProperties([]element.Property{leafProp}) + + // Precondition: everything clean + if root.IsDirty() || mid.IsDirty() || leaf.IsDirty() { + t.Fatal("precondition failed: all should be clean") + } + + // Modify leaf property + leafProp.Set("changed") + + // Verify propagation + if !leaf.IsDirty() { + t.Error("leaf should be dirty") + } + leafBits := leaf.DirtyBits() + if len(leafBits) < 1 || leafBits[0]&(1<<0) == 0 { + t.Error("leaf bit 0 should be set") + } + if !mid.IsDirty() { + t.Error("mid should be dirty (child-dirty)") + } + if !mid.IsChildDirty() { + t.Error("mid should have childDirty set") + } + if !root.IsDirty() { + t.Error("root should be dirty (child-dirty)") + } + if !root.IsChildDirty() { + t.Error("root should have childDirty set") + } + + // Root's own property should NOT be dirty + if rootProp.Dirty() { + t.Error("root's own property should not be dirty") + } +} + +// TestPartListAppendSetsContainerAndBubbles verifies that PartList.Append +// sets the child's container AND bubbles dirty up. +func TestPartListAppendSetsContainerAndBubbles(t *testing.T) { + parent := &element.Base{} + pl := property.NewPartList[element.Element]("Items") + pl.Bind(parent, 3) + parent.SetProperties([]element.Property{pl}) + + child := &element.Base{} + child.SetTypeName("Test$Child") + child.MarkDirty(63) // new element + + pl.Append(child) + + // Child's container should be parent + if child.Container() != parent { + t.Error("child.Container should be parent after Append") + } + + // Parent should be dirty (bit 3 = PartList modified) + parentBits := parent.DirtyBits() + if len(parentBits) < 1 || parentBits[0]&(1<<3) == 0 { + t.Error("parent bit 3 should be set (PartList modified)") + } +} + +// TestDecodeChildMutationBubblesUp verifies that mutating a child +// element loaded via AppendFromDecode correctly propagates dirty +// state to the parent container. +func TestDecodeChildMutationBubblesUp(t *testing.T) { + parent := &element.Base{} + pl := property.NewPartList[element.Element]("Items") + pl.Bind(parent, 3) + parent.SetProperties([]element.Property{pl}) + + child := &element.Base{} + childProp := property.NewPrimitive[string]("Name", property.DecodeString) + childProp.Bind(child, 0) + child.SetProperties([]element.Property{childProp}) + + pl.AppendFromDecode(child) + + if parent.IsDirty() { + t.Fatal("parent should be clean after decode") + } + if child.IsDirty() { + t.Fatal("child should be clean after decode") + } + if child.Container() != parent { + t.Fatal("child.Container should be parent after AppendFromDecode") + } + + childProp.Set("modified") + + if !child.IsDirty() { + t.Error("child should be dirty after Set") + } + if !parent.IsDirty() { + t.Error("parent should be dirty (childDirty) after child mutation") + } + if !parent.IsChildDirty() { + t.Error("parent.childDirty should be true") + } +} + +// TestDecodePartChildMutationBubblesUp verifies that mutating a child +// element loaded via Part.SetFromDecode correctly propagates dirty +// state to the parent container. +func TestDecodePartChildMutationBubblesUp(t *testing.T) { + parent := &element.Base{} + pt := property.NewPart[element.Element]("Child") + pt.Bind(parent, 1) + parent.SetProperties([]element.Property{pt}) + + child := &element.Base{} + childProp := property.NewPrimitive[string]("Name", property.DecodeString) + childProp.Bind(child, 0) + child.SetProperties([]element.Property{childProp}) + + pt.SetFromDecode(child) + + if parent.IsDirty() { + t.Fatal("parent should be clean after decode") + } + if child.Container() != parent { + t.Fatal("child.Container should be parent after SetFromDecode") + } + + childProp.Set("modified") + if !parent.IsDirty() { + t.Error("parent should be dirty after child mutation") + } + if !parent.IsChildDirty() { + t.Error("parent.childDirty should be true") + } +} + +// TestCleanElementNotDirtyAfterDecode simulates decoding an element from BSON +// and verifies it stays clean. +func TestCleanElementNotDirtyAfterDecode(t *testing.T) { + elem := &element.Base{} + elem.SetID("test-id") + elem.SetTypeName("Test$Clean") + + p := property.NewPrimitive[string]("Name", property.DecodeString) + p.Bind(elem, 0) + elem.SetProperties([]element.Property{p}) + + // Simulate decode: SetFromDecode-style operations don't mark dirty + // (Primitive doesn't have SetFromDecode, but Init + Get doesn't dirty) + if elem.IsDirty() { + t.Error("freshly constructed element should not be dirty") + } + if p.Dirty() { + t.Error("property should not be dirty before Set") + } +} diff --git a/modelsdk/element/element.go b/modelsdk/element/element.go new file mode 100644 index 00000000..95215bb6 --- /dev/null +++ b/modelsdk/element/element.go @@ -0,0 +1,143 @@ +package element + +import ( + "go.mongodb.org/mongo-driver/bson" +) + +type ID string + +type Property interface { + Name() string +} + +// WritableProperty is implemented by properties that can report dirty state +// and encode their current value for BSON serialization. +type WritableProperty interface { + Property + Dirty() bool + // BSONValue returns the current value suitable for bson.D insertion. + // For Part/PartList properties, returns nil — use ChildProperty/ChildListProperty instead. + BSONValue() any +} + +// ChildProperty is a Part-like property holding a single child Element. +type ChildProperty interface { + WritableProperty + ChildElement() Element +} + +// ChildListProperty is a PartList-like property holding a list of child Elements. +type ChildListProperty interface { + WritableProperty + ChildElements() []Element +} + +type Element interface { + ID() ID + TypeName() string + Container() Element + SetContainer(c Element) + Unit() Unit + Raw() bson.Raw + IsDirty() bool + Properties() []Property +} + +type Unit interface { + Element + UnitID() ID + IsLoaded() bool +} + +type ContainerUnit interface { + Unit + Units() []Unit +} + +type Base struct { + id ID + typeName string + container Element + unit Unit + raw bson.Raw + dirty []uint64 + childDirty bool + props []Property +} + +func (b *Base) ID() ID { return b.id } +func (b *Base) SetID(id ID) { b.id = id } +func (b *Base) TypeName() string { return b.typeName } +func (b *Base) SetTypeName(t string) { b.typeName = t } +func (b *Base) Container() Element { return b.container } +func (b *Base) SetContainer(c Element) { b.container = c } +func (b *Base) Unit() Unit { return b.unit } +func (b *Base) SetUnit(u Unit) { b.unit = u } +func (b *Base) Raw() bson.Raw { return b.raw } +func (b *Base) SetRaw(r bson.Raw) { b.raw = r } +func (b *Base) IsDirty() bool { + if b.childDirty { + return true + } + for _, w := range b.dirty { + if w != 0 { + return true + } + } + return false +} +func (b *Base) MarkDirty(bit uint) { + word := bit / 64 + for len(b.dirty) <= int(word) { + b.dirty = append(b.dirty, 0) + } + b.dirty[word] |= 1 << (bit % 64) + if b.container != nil { + if mc, ok := b.container.(interface{ MarkChildDirty() }); ok { + mc.MarkChildDirty() + } + } +} +func (b *Base) MarkChildDirty() { + if b.childDirty { + return // already marked, stop recursion + } + b.childDirty = true + if b.container != nil { + if mc, ok := b.container.(interface{ MarkChildDirty() }); ok { + mc.MarkChildDirty() + } + } +} + +// DirtyBits returns the raw dirty bitmap words. +func (b *Base) DirtyBits() []uint64 { return b.dirty } + +// IsChildDirty returns true if a child element was modified. +func (b *Base) IsChildDirty() bool { return b.childDirty } +func (b *Base) Properties() []Property { return b.props } +func (b *Base) SetProperties(p []Property) { b.props = p } + +// NameValue returns the Name field from the underlying raw BSON. +// Returns "" if the element has no Name field or no raw BSON. +func (b *Base) NameValue() string { + if b.raw == nil { + return "" + } + val, err := b.raw.LookupErr("Name") + if err != nil { + return "" + } + s, _ := val.StringValueOK() + return s +} + +// AddProperty appends a property and binds it to this element. +// Use this to inject inherited or ad-hoc properties that the codegen +// doesn't produce (e.g. Document.Name on Microflow). +func (b *Base) AddProperty(p Property, bit uint) { + if binder, ok := p.(interface{ Bind(owner *Base, bit uint) }); ok { + binder.Bind(b, bit) + } + b.props = append(b.props, p) +} diff --git a/modelsdk/element/element_test.go b/modelsdk/element/element_test.go new file mode 100644 index 00000000..efa483f5 --- /dev/null +++ b/modelsdk/element/element_test.go @@ -0,0 +1,106 @@ +package element + +import ( + "testing" + + "go.mongodb.org/mongo-driver/bson" +) + +func TestBase_SetID_ID(t *testing.T) { + var b Base + if got := b.ID(); got != "" { + t.Fatalf("expected empty ID, got %q", got) + } + b.SetID("abc-123") + if got := b.ID(); got != "abc-123" { + t.Fatalf("expected %q, got %q", "abc-123", got) + } +} + +func TestBase_SetTypeName_TypeName(t *testing.T) { + var b Base + if got := b.TypeName(); got != "" { + t.Fatalf("expected empty TypeName, got %q", got) + } + b.SetTypeName("DomainModels$DomainModel") + if got := b.TypeName(); got != "DomainModels$DomainModel" { + t.Fatalf("expected %q, got %q", "DomainModels$DomainModel", got) + } +} + +func TestBase_IsDirty(t *testing.T) { + var b Base + if b.IsDirty() { + t.Fatal("expected IsDirty false on zero-value Base") + } + b.MarkDirty(0) + if !b.IsDirty() { + t.Fatal("expected IsDirty true after MarkDirty(0)") + } + + var b2 Base + b2.MarkDirty(63) + if !b2.IsDirty() { + t.Fatal("expected IsDirty true after MarkDirty(63)") + } + bits := b2.DirtyBits() + if len(bits) < 1 || bits[0]&(1<<63) == 0 { + t.Fatalf("unexpected dirty bits: bit 63 not set") + } +} + +func TestMarkDirtyBubbles(t *testing.T) { + var parent, child Base + child.SetContainer(&parent) + + child.MarkDirty(0) + + if !child.IsDirty() { + t.Fatal("child should be dirty after MarkDirty(0)") + } + if !parent.childDirty { + t.Fatal("parent should have childDirty set after child.MarkDirty(0)") + } +} + +func TestMarkChildDirtyIdempotent(t *testing.T) { + var b Base + b.MarkChildDirty() + b.MarkChildDirty() + if !b.childDirty { + t.Fatal("expected childDirty to be true") + } + // dirty bitmap should be empty — childDirty is a separate flag + for _, w := range b.dirty { + if w != 0 { + t.Fatalf("expected empty dirty bitmap, got non-zero word") + } + } +} + +func TestDeepBubble(t *testing.T) { + var root, mid, leaf Base + mid.SetContainer(&root) + leaf.SetContainer(&mid) + + leaf.MarkDirty(0) + + if !mid.childDirty { + t.Fatal("mid should have childDirty set") + } + if !root.childDirty { + t.Fatal("root should have childDirty set") + } +} + +func TestBase_SetRaw_Raw(t *testing.T) { + var b Base + if b.Raw() != nil { + t.Fatal("expected nil Raw on zero-value Base") + } + raw := bson.Raw([]byte{5, 0, 0, 0, 0}) // minimal valid BSON doc + b.SetRaw(raw) + if got := b.Raw(); string(got) != string(raw) { + t.Fatalf("Raw mismatch: got %v, want %v", got, raw) + } +} diff --git a/modelsdk/element/walk.go b/modelsdk/element/walk.go new file mode 100644 index 00000000..4a30ac63 --- /dev/null +++ b/modelsdk/element/walk.go @@ -0,0 +1,80 @@ +package element + +// Walk recursively traverses an Element tree in depth-first order. +// fn is called for each element; return false to stop traversal. +func Walk(root Element, fn func(elem Element) bool) { + walkImpl(root, fn) +} + +func walkImpl(root Element, fn func(Element) bool) bool { + if !fn(root) { + return false + } + for _, prop := range root.Properties() { + switch p := prop.(type) { + case ChildProperty: + if child := p.ChildElement(); child != nil { + if !walkImpl(child, fn) { + return false + } + } + case ChildListProperty: + for _, child := range p.ChildElements() { + if !walkImpl(child, fn) { + return false + } + } + } + } + return true +} + +// FindByName searches the element tree for the first element whose +// Name() method returns the given name. Returns nil if not found. +func FindByName(root Element, name string) Element { + type namer interface{ Name() string } + var found Element + Walk(root, func(e Element) bool { + if n, ok := e.(namer); ok && n.Name() == name { + found = e + return false + } + return true + }) + return found +} + +// WalkStrings visits every WritableProperty on every element in the tree, +// calling fn for each string-valued property. Return false to stop. +func WalkStrings(root Element, fn func(elem Element, propName string, value string) bool) { + walkStringsImpl(root, fn) +} + +func walkStringsImpl(root Element, fn func(Element, string, string) bool) bool { + for _, prop := range root.Properties() { + if wp, ok := prop.(WritableProperty); ok { + if v := wp.BSONValue(); v != nil { + if s, ok := v.(string); ok && s != "" { + if !fn(root, prop.Name(), s) { + return false + } + } + } + } + switch p := prop.(type) { + case ChildProperty: + if child := p.ChildElement(); child != nil { + if !walkStringsImpl(child, fn) { + return false + } + } + case ChildListProperty: + for _, child := range p.ChildElements() { + if !walkStringsImpl(child, fn) { + return false + } + } + } + } + return true +} diff --git a/modelsdk/gen/appservices/enums.go b/modelsdk/gen/appservices/enums.go new file mode 100644 index 00000000..6e53ead3 --- /dev/null +++ b/modelsdk/gen/appservices/enums.go @@ -0,0 +1,14 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package appservices + +// AppServiceLocationEnum enumerates the possible values for the AppServiceLocationEnum type. +type AppServiceLocationEnum = string + +const ( + AppServiceLocationEnumDefault AppServiceLocationEnum = "Default" + AppServiceLocationEnumConstant AppServiceLocationEnum = "Constant" + AppServiceLocationEnumParameter AppServiceLocationEnum = "Parameter" +) diff --git a/modelsdk/gen/appservices/refs.go b/modelsdk/gen/appservices/refs.go new file mode 100644 index 00000000..612e6330 --- /dev/null +++ b/modelsdk/gen/appservices/refs.go @@ -0,0 +1,16 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package appservices + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("AppServices$AppServiceAction", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("AppServices$ConsumedAppService", []codec.RefMeta{ + {Prop: "LocationConstant", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) +} diff --git a/modelsdk/gen/appservices/types.go b/modelsdk/gen/appservices/types.go new file mode 100644 index 00000000..cd89c547 --- /dev/null +++ b/modelsdk/gen/appservices/types.go @@ -0,0 +1,2074 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package appservices + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// AppServiceAction +// ──────────────────────────────────────────────────────── + +type AppServiceAction struct { + element.Base + name *property.Primitive[string] + caption *property.Primitive[string] + description *property.Primitive[string] + parameters *property.PartList[element.Element] + microflow *property.ByNameRef[element.Element] + returnType *property.Primitive[string] + actionReturnType *property.Part[element.Element] + returnTypeCanBeEmpty *property.Primitive[bool] + image *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *AppServiceAction) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *AppServiceAction) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *AppServiceAction) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *AppServiceAction) SetCaption(v string) { + o.caption.Set(v) +} + +// Description returns the value of the description property. +func (o *AppServiceAction) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *AppServiceAction) SetDescription(v string) { + o.description.Set(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *AppServiceAction) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *AppServiceAction) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *AppServiceAction) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *AppServiceAction) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *AppServiceAction) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ReturnType returns the value of the returnType property. +func (o *AppServiceAction) ReturnType() string { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *AppServiceAction) SetReturnType(v string) { + o.returnType.Set(v) +} + +// ActionReturnType returns the value of the actionReturnType property. +func (o *AppServiceAction) ActionReturnType() element.Element { + return o.actionReturnType.Get() +} + +// SetActionReturnType sets the value of the actionReturnType property. +func (o *AppServiceAction) SetActionReturnType(v element.Element) { + o.actionReturnType.Set(v) +} + +// ReturnTypeCanBeEmpty returns the value of the returnTypeCanBeEmpty property. +func (o *AppServiceAction) ReturnTypeCanBeEmpty() bool { + return o.returnTypeCanBeEmpty.Get() +} + +// SetReturnTypeCanBeEmpty sets the value of the returnTypeCanBeEmpty property. +func (o *AppServiceAction) SetReturnTypeCanBeEmpty(v bool) { + o.returnTypeCanBeEmpty.Set(v) +} + +// Image returns the value of the image property. +func (o *AppServiceAction) Image() string { + return o.image.Get() +} + +// SetImage sets the value of the image property. +func (o *AppServiceAction) SetImage(v string) { + o.image.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AppServiceAction) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.caption.Init(raw) + o.description.Init(raw) + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + o.returnType.Init(raw) + if child, err := codec.DecodeChild(raw, "ActionReturnType"); err == nil { + o.actionReturnType.SetFromDecode(child) + } + o.returnTypeCanBeEmpty.Init(raw) + o.image.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// AppServiceActionParameter +// ──────────────────────────────────────────────────────── + +type AppServiceActionParameter struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + parameterType *property.Part[element.Element] + canBeEmpty *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *AppServiceActionParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *AppServiceActionParameter) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *AppServiceActionParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *AppServiceActionParameter) SetType(v string) { + o.propType.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *AppServiceActionParameter) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *AppServiceActionParameter) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// CanBeEmpty returns the value of the canBeEmpty property. +func (o *AppServiceActionParameter) CanBeEmpty() bool { + return o.canBeEmpty.Get() +} + +// SetCanBeEmpty sets the value of the canBeEmpty property. +func (o *AppServiceActionParameter) SetCanBeEmpty(v bool) { + o.canBeEmpty.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AppServiceActionParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } + o.canBeEmpty.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConsumedAppService +// ──────────────────────────────────────────────────────── + +type ConsumedAppService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + actions *property.PartList[element.Element] + msd *property.Part[element.Element] + fromAppStore *property.Primitive[bool] + appStoreGuid *property.Primitive[string] + appStoreVersionGuid *property.Primitive[string] + appStoreVersion *property.Primitive[string] + appServiceLocation *property.Enum[string] + locationConstant *property.ByNameRef[element.Element] + useTimeOut *property.Primitive[bool] + timeOut *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *ConsumedAppService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConsumedAppService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ConsumedAppService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ConsumedAppService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ConsumedAppService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ConsumedAppService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ConsumedAppService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ConsumedAppService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ActionsItems returns the value of the actions property. +func (o *ConsumedAppService) ActionsItems() []element.Element { + return o.actions.Items() +} + +// AddActions appends a child element to the actions list. +func (o *ConsumedAppService) AddActions(v element.Element) { + o.actions.Append(v) +} + +// RemoveActions removes the element at the given index from the actions list. +func (o *ConsumedAppService) RemoveActions(index int) { + o.actions.Remove(index) +} + +// Msd returns the value of the msd property. +func (o *ConsumedAppService) Msd() element.Element { + return o.msd.Get() +} + +// SetMsd sets the value of the msd property. +func (o *ConsumedAppService) SetMsd(v element.Element) { + o.msd.Set(v) +} + +// FromAppStore returns the value of the fromAppStore property. +func (o *ConsumedAppService) FromAppStore() bool { + return o.fromAppStore.Get() +} + +// SetFromAppStore sets the value of the fromAppStore property. +func (o *ConsumedAppService) SetFromAppStore(v bool) { + o.fromAppStore.Set(v) +} + +// AppStoreGuid returns the value of the appStoreGuid property. +func (o *ConsumedAppService) AppStoreGuid() string { + return o.appStoreGuid.Get() +} + +// SetAppStoreGuid sets the value of the appStoreGuid property. +func (o *ConsumedAppService) SetAppStoreGuid(v string) { + o.appStoreGuid.Set(v) +} + +// AppStoreVersionGuid returns the value of the appStoreVersionGuid property. +func (o *ConsumedAppService) AppStoreVersionGuid() string { + return o.appStoreVersionGuid.Get() +} + +// SetAppStoreVersionGuid sets the value of the appStoreVersionGuid property. +func (o *ConsumedAppService) SetAppStoreVersionGuid(v string) { + o.appStoreVersionGuid.Set(v) +} + +// AppStoreVersion returns the value of the appStoreVersion property. +func (o *ConsumedAppService) AppStoreVersion() string { + return o.appStoreVersion.Get() +} + +// SetAppStoreVersion sets the value of the appStoreVersion property. +func (o *ConsumedAppService) SetAppStoreVersion(v string) { + o.appStoreVersion.Set(v) +} + +// AppServiceLocation returns the value of the appServiceLocation property. +func (o *ConsumedAppService) AppServiceLocation() string { + return o.appServiceLocation.Get() +} + +// SetAppServiceLocation sets the value of the appServiceLocation property. +func (o *ConsumedAppService) SetAppServiceLocation(v string) { + o.appServiceLocation.Set(v) +} + +// LocationConstantQualifiedName returns the value of the locationConstant property. +func (o *ConsumedAppService) LocationConstantQualifiedName() string { + return o.locationConstant.QualifiedName() +} + +// SetLocationConstantQualifiedName sets the value of the locationConstant property. +func (o *ConsumedAppService) SetLocationConstantQualifiedName(v string) { + o.locationConstant.SetQualifiedName(v) +} + +// UseTimeOut returns the value of the useTimeOut property. +func (o *ConsumedAppService) UseTimeOut() bool { + return o.useTimeOut.Get() +} + +// SetUseTimeOut sets the value of the useTimeOut property. +func (o *ConsumedAppService) SetUseTimeOut(v bool) { + o.useTimeOut.Set(v) +} + +// TimeOut returns the value of the timeOut property. +func (o *ConsumedAppService) TimeOut() int32 { + return o.timeOut.Get() +} + +// SetTimeOut sets the value of the timeOut property. +func (o *ConsumedAppService) SetTimeOut(v int32) { + o.timeOut.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConsumedAppService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Actions"); err == nil { + for _, child := range children { + o.actions.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Msd"); err == nil { + o.msd.SetFromDecode(child) + } + o.fromAppStore.Init(raw) + o.appStoreGuid.Init(raw) + o.appStoreVersionGuid.Init(raw) + o.appStoreVersion.Init(raw) + if val, err := raw.LookupErr("AppServiceLocation"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.appServiceLocation.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("LocationConstant"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.locationConstant.SetFromDecode(s) + } + } + o.useTimeOut.Init(raw) + o.timeOut.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Msd +// ──────────────────────────────────────────────────────── + +type Msd struct { + element.Base + version *property.Part[element.Element] + metadata *property.Part[element.Element] + domainModel *property.Part[element.Element] + enumerations *property.Part[element.Element] + wsdlDescription *property.Part[element.Element] + wsdl *property.Primitive[string] +} + +// Version returns the value of the version property. +func (o *Msd) Version() element.Element { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *Msd) SetVersion(v element.Element) { + o.version.Set(v) +} + +// Metadata returns the value of the metadata property. +func (o *Msd) Metadata() element.Element { + return o.metadata.Get() +} + +// SetMetadata sets the value of the metadata property. +func (o *Msd) SetMetadata(v element.Element) { + o.metadata.Set(v) +} + +// DomainModel returns the value of the domainModel property. +func (o *Msd) DomainModel() element.Element { + return o.domainModel.Get() +} + +// SetDomainModel sets the value of the domainModel property. +func (o *Msd) SetDomainModel(v element.Element) { + o.domainModel.Set(v) +} + +// Enumerations returns the value of the enumerations property. +func (o *Msd) Enumerations() element.Element { + return o.enumerations.Get() +} + +// SetEnumerations sets the value of the enumerations property. +func (o *Msd) SetEnumerations(v element.Element) { + o.enumerations.Set(v) +} + +// WsdlDescription returns the value of the wsdlDescription property. +func (o *Msd) WsdlDescription() element.Element { + return o.wsdlDescription.Get() +} + +// SetWsdlDescription sets the value of the wsdlDescription property. +func (o *Msd) SetWsdlDescription(v element.Element) { + o.wsdlDescription.Set(v) +} + +// Wsdl returns the value of the wsdl property. +func (o *Msd) Wsdl() string { + return o.wsdl.Get() +} + +// SetWsdl sets the value of the wsdl property. +func (o *Msd) SetWsdl(v string) { + o.wsdl.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Msd) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Version"); err == nil { + o.version.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Metadata"); err == nil { + o.metadata.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DomainModel"); err == nil { + o.domainModel.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Enumerations"); err == nil { + o.enumerations.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "WsdlDescription"); err == nil { + o.wsdlDescription.SetFromDecode(child) + } + o.wsdl.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MsdAssociation +// ──────────────────────────────────────────────────────── + +type MsdAssociation struct { + element.Base + name *property.Primitive[string] + guid *property.Primitive[string] + parentEntityName *property.Primitive[string] + childEntityName *property.Primitive[string] + associationType *property.Primitive[string] + associationOwner *property.Primitive[string] + parentDeleteBehavior *property.Primitive[string] + childDeleteBehavior *property.Primitive[string] + associationKind *property.Primitive[string] + parentX *property.Primitive[int32] + parentY *property.Primitive[int32] + childX *property.Primitive[int32] + childY *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *MsdAssociation) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MsdAssociation) SetName(v string) { + o.name.Set(v) +} + +// Guid returns the value of the guid property. +func (o *MsdAssociation) Guid() string { + return o.guid.Get() +} + +// SetGuid sets the value of the guid property. +func (o *MsdAssociation) SetGuid(v string) { + o.guid.Set(v) +} + +// ParentEntityName returns the value of the parentEntityName property. +func (o *MsdAssociation) ParentEntityName() string { + return o.parentEntityName.Get() +} + +// SetParentEntityName sets the value of the parentEntityName property. +func (o *MsdAssociation) SetParentEntityName(v string) { + o.parentEntityName.Set(v) +} + +// ChildEntityName returns the value of the childEntityName property. +func (o *MsdAssociation) ChildEntityName() string { + return o.childEntityName.Get() +} + +// SetChildEntityName sets the value of the childEntityName property. +func (o *MsdAssociation) SetChildEntityName(v string) { + o.childEntityName.Set(v) +} + +// AssociationType returns the value of the associationType property. +func (o *MsdAssociation) AssociationType() string { + return o.associationType.Get() +} + +// SetAssociationType sets the value of the associationType property. +func (o *MsdAssociation) SetAssociationType(v string) { + o.associationType.Set(v) +} + +// AssociationOwner returns the value of the associationOwner property. +func (o *MsdAssociation) AssociationOwner() string { + return o.associationOwner.Get() +} + +// SetAssociationOwner sets the value of the associationOwner property. +func (o *MsdAssociation) SetAssociationOwner(v string) { + o.associationOwner.Set(v) +} + +// ParentDeleteBehavior returns the value of the parentDeleteBehavior property. +func (o *MsdAssociation) ParentDeleteBehavior() string { + return o.parentDeleteBehavior.Get() +} + +// SetParentDeleteBehavior sets the value of the parentDeleteBehavior property. +func (o *MsdAssociation) SetParentDeleteBehavior(v string) { + o.parentDeleteBehavior.Set(v) +} + +// ChildDeleteBehavior returns the value of the childDeleteBehavior property. +func (o *MsdAssociation) ChildDeleteBehavior() string { + return o.childDeleteBehavior.Get() +} + +// SetChildDeleteBehavior sets the value of the childDeleteBehavior property. +func (o *MsdAssociation) SetChildDeleteBehavior(v string) { + o.childDeleteBehavior.Set(v) +} + +// AssociationKind returns the value of the associationKind property. +func (o *MsdAssociation) AssociationKind() string { + return o.associationKind.Get() +} + +// SetAssociationKind sets the value of the associationKind property. +func (o *MsdAssociation) SetAssociationKind(v string) { + o.associationKind.Set(v) +} + +// ParentX returns the value of the parentX property. +func (o *MsdAssociation) ParentX() int32 { + return o.parentX.Get() +} + +// SetParentX sets the value of the parentX property. +func (o *MsdAssociation) SetParentX(v int32) { + o.parentX.Set(v) +} + +// ParentY returns the value of the parentY property. +func (o *MsdAssociation) ParentY() int32 { + return o.parentY.Get() +} + +// SetParentY sets the value of the parentY property. +func (o *MsdAssociation) SetParentY(v int32) { + o.parentY.Set(v) +} + +// ChildX returns the value of the childX property. +func (o *MsdAssociation) ChildX() int32 { + return o.childX.Get() +} + +// SetChildX sets the value of the childX property. +func (o *MsdAssociation) SetChildX(v int32) { + o.childX.Set(v) +} + +// ChildY returns the value of the childY property. +func (o *MsdAssociation) ChildY() int32 { + return o.childY.Get() +} + +// SetChildY sets the value of the childY property. +func (o *MsdAssociation) SetChildY(v int32) { + o.childY.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdAssociation) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.guid.Init(raw) + o.parentEntityName.Init(raw) + o.childEntityName.Init(raw) + o.associationType.Init(raw) + o.associationOwner.Init(raw) + o.parentDeleteBehavior.Init(raw) + o.childDeleteBehavior.Init(raw) + o.associationKind.Init(raw) + o.parentX.Init(raw) + o.parentY.Init(raw) + o.childX.Init(raw) + o.childY.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MsdAttribute +// ──────────────────────────────────────────────────────── + +type MsdAttribute struct { + element.Base + name *property.Primitive[string] + guid *property.Primitive[string] + attributeType *property.Primitive[string] + enumerationName *property.Primitive[string] + defaultValue *property.Primitive[string] + length *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *MsdAttribute) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MsdAttribute) SetName(v string) { + o.name.Set(v) +} + +// Guid returns the value of the guid property. +func (o *MsdAttribute) Guid() string { + return o.guid.Get() +} + +// SetGuid sets the value of the guid property. +func (o *MsdAttribute) SetGuid(v string) { + o.guid.Set(v) +} + +// AttributeType returns the value of the attributeType property. +func (o *MsdAttribute) AttributeType() string { + return o.attributeType.Get() +} + +// SetAttributeType sets the value of the attributeType property. +func (o *MsdAttribute) SetAttributeType(v string) { + o.attributeType.Set(v) +} + +// EnumerationName returns the value of the enumerationName property. +func (o *MsdAttribute) EnumerationName() string { + return o.enumerationName.Get() +} + +// SetEnumerationName sets the value of the enumerationName property. +func (o *MsdAttribute) SetEnumerationName(v string) { + o.enumerationName.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *MsdAttribute) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *MsdAttribute) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// Length returns the value of the length property. +func (o *MsdAttribute) Length() int32 { + return o.length.Get() +} + +// SetLength sets the value of the length property. +func (o *MsdAttribute) SetLength(v int32) { + o.length.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdAttribute) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.guid.Init(raw) + o.attributeType.Init(raw) + o.enumerationName.Init(raw) + o.defaultValue.Init(raw) + o.length.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MsdDomainModel +// ──────────────────────────────────────────────────────── + +type MsdDomainModel struct { + element.Base + entities *property.PartList[element.Element] + associations *property.PartList[element.Element] +} + +// EntitiesItems returns the value of the entities property. +func (o *MsdDomainModel) EntitiesItems() []element.Element { + return o.entities.Items() +} + +// AddEntities appends a child element to the entities list. +func (o *MsdDomainModel) AddEntities(v element.Element) { + o.entities.Append(v) +} + +// RemoveEntities removes the element at the given index from the entities list. +func (o *MsdDomainModel) RemoveEntities(index int) { + o.entities.Remove(index) +} + +// AssociationsItems returns the value of the associations property. +func (o *MsdDomainModel) AssociationsItems() []element.Element { + return o.associations.Items() +} + +// AddAssociations appends a child element to the associations list. +func (o *MsdDomainModel) AddAssociations(v element.Element) { + o.associations.Append(v) +} + +// RemoveAssociations removes the element at the given index from the associations list. +func (o *MsdDomainModel) RemoveAssociations(index int) { + o.associations.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdDomainModel) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Entities"); err == nil { + for _, child := range children { + o.entities.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Associations"); err == nil { + for _, child := range children { + o.associations.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MsdEntity +// ──────────────────────────────────────────────────────── + +type MsdEntity struct { + element.Base + name *property.Primitive[string] + guid *property.Primitive[string] + generalizationName *property.Primitive[string] + persistable *property.Primitive[bool] + locationX *property.Primitive[int32] + locationY *property.Primitive[int32] + attributes *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *MsdEntity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MsdEntity) SetName(v string) { + o.name.Set(v) +} + +// Guid returns the value of the guid property. +func (o *MsdEntity) Guid() string { + return o.guid.Get() +} + +// SetGuid sets the value of the guid property. +func (o *MsdEntity) SetGuid(v string) { + o.guid.Set(v) +} + +// GeneralizationName returns the value of the generalizationName property. +func (o *MsdEntity) GeneralizationName() string { + return o.generalizationName.Get() +} + +// SetGeneralizationName sets the value of the generalizationName property. +func (o *MsdEntity) SetGeneralizationName(v string) { + o.generalizationName.Set(v) +} + +// Persistable returns the value of the persistable property. +func (o *MsdEntity) Persistable() bool { + return o.persistable.Get() +} + +// SetPersistable sets the value of the persistable property. +func (o *MsdEntity) SetPersistable(v bool) { + o.persistable.Set(v) +} + +// LocationX returns the value of the locationX property. +func (o *MsdEntity) LocationX() int32 { + return o.locationX.Get() +} + +// SetLocationX sets the value of the locationX property. +func (o *MsdEntity) SetLocationX(v int32) { + o.locationX.Set(v) +} + +// LocationY returns the value of the locationY property. +func (o *MsdEntity) LocationY() int32 { + return o.locationY.Get() +} + +// SetLocationY sets the value of the locationY property. +func (o *MsdEntity) SetLocationY(v int32) { + o.locationY.Set(v) +} + +// AttributesItems returns the value of the attributes property. +func (o *MsdEntity) AttributesItems() []element.Element { + return o.attributes.Items() +} + +// AddAttributes appends a child element to the attributes list. +func (o *MsdEntity) AddAttributes(v element.Element) { + o.attributes.Append(v) +} + +// RemoveAttributes removes the element at the given index from the attributes list. +func (o *MsdEntity) RemoveAttributes(index int) { + o.attributes.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdEntity) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.guid.Init(raw) + o.generalizationName.Init(raw) + o.persistable.Init(raw) + o.locationX.Init(raw) + o.locationY.Init(raw) + if children, err := codec.DecodeChildren(raw, "Attributes"); err == nil { + for _, child := range children { + o.attributes.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MsdEnumeration +// ──────────────────────────────────────────────────────── + +type MsdEnumeration struct { + element.Base + name *property.Primitive[string] + guid *property.Primitive[string] + values *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *MsdEnumeration) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MsdEnumeration) SetName(v string) { + o.name.Set(v) +} + +// Guid returns the value of the guid property. +func (o *MsdEnumeration) Guid() string { + return o.guid.Get() +} + +// SetGuid sets the value of the guid property. +func (o *MsdEnumeration) SetGuid(v string) { + o.guid.Set(v) +} + +// ValuesItems returns the value of the values property. +func (o *MsdEnumeration) ValuesItems() []element.Element { + return o.values.Items() +} + +// AddValues appends a child element to the values list. +func (o *MsdEnumeration) AddValues(v element.Element) { + o.values.Append(v) +} + +// RemoveValues removes the element at the given index from the values list. +func (o *MsdEnumeration) RemoveValues(index int) { + o.values.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdEnumeration) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.guid.Init(raw) + if children, err := codec.DecodeChildren(raw, "Values"); err == nil { + for _, child := range children { + o.values.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MsdEnumerationContainer +// ──────────────────────────────────────────────────────── + +type MsdEnumerationContainer struct { + element.Base + enumerations *property.PartList[element.Element] +} + +// EnumerationsItems returns the value of the enumerations property. +func (o *MsdEnumerationContainer) EnumerationsItems() []element.Element { + return o.enumerations.Items() +} + +// AddEnumerations appends a child element to the enumerations list. +func (o *MsdEnumerationContainer) AddEnumerations(v element.Element) { + o.enumerations.Append(v) +} + +// RemoveEnumerations removes the element at the given index from the enumerations list. +func (o *MsdEnumerationContainer) RemoveEnumerations(index int) { + o.enumerations.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdEnumerationContainer) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Enumerations"); err == nil { + for _, child := range children { + o.enumerations.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MsdEnumerationValue +// ──────────────────────────────────────────────────────── + +type MsdEnumerationValue struct { + element.Base + name *property.Primitive[string] + guid *property.Primitive[string] + translations *property.PartList[element.Element] + image *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *MsdEnumerationValue) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MsdEnumerationValue) SetName(v string) { + o.name.Set(v) +} + +// Guid returns the value of the guid property. +func (o *MsdEnumerationValue) Guid() string { + return o.guid.Get() +} + +// SetGuid sets the value of the guid property. +func (o *MsdEnumerationValue) SetGuid(v string) { + o.guid.Set(v) +} + +// TranslationsItems returns the value of the translations property. +func (o *MsdEnumerationValue) TranslationsItems() []element.Element { + return o.translations.Items() +} + +// AddTranslations appends a child element to the translations list. +func (o *MsdEnumerationValue) AddTranslations(v element.Element) { + o.translations.Append(v) +} + +// RemoveTranslations removes the element at the given index from the translations list. +func (o *MsdEnumerationValue) RemoveTranslations(index int) { + o.translations.Remove(index) +} + +// Image returns the value of the image property. +func (o *MsdEnumerationValue) Image() string { + return o.image.Get() +} + +// SetImage sets the value of the image property. +func (o *MsdEnumerationValue) SetImage(v string) { + o.image.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdEnumerationValue) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.guid.Init(raw) + if children, err := codec.DecodeChildren(raw, "Translations"); err == nil { + for _, child := range children { + o.translations.AppendFromDecode(child) + } + } + o.image.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MsdMetadata +// ──────────────────────────────────────────────────────── + +type MsdMetadata struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + version *property.Primitive[int32] + publishDateTime *property.Primitive[string] + serviceGuid *property.Primitive[string] + versionGuid *property.Primitive[string] + instanceGuid *property.Primitive[string] + supportedProtocols *property.Primitive[string] + headerAuthentication *property.Primitive[string] + microflows *property.PartList[element.Element] + caption *property.Primitive[string] + image *property.Primitive[string] + description *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *MsdMetadata) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MsdMetadata) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MsdMetadata) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MsdMetadata) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Version returns the value of the version property. +func (o *MsdMetadata) Version() int32 { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *MsdMetadata) SetVersion(v int32) { + o.version.Set(v) +} + +// PublishDateTime returns the value of the publishDateTime property. +func (o *MsdMetadata) PublishDateTime() string { + return o.publishDateTime.Get() +} + +// SetPublishDateTime sets the value of the publishDateTime property. +func (o *MsdMetadata) SetPublishDateTime(v string) { + o.publishDateTime.Set(v) +} + +// ServiceGuid returns the value of the serviceGuid property. +func (o *MsdMetadata) ServiceGuid() string { + return o.serviceGuid.Get() +} + +// SetServiceGuid sets the value of the serviceGuid property. +func (o *MsdMetadata) SetServiceGuid(v string) { + o.serviceGuid.Set(v) +} + +// VersionGuid returns the value of the versionGuid property. +func (o *MsdMetadata) VersionGuid() string { + return o.versionGuid.Get() +} + +// SetVersionGuid sets the value of the versionGuid property. +func (o *MsdMetadata) SetVersionGuid(v string) { + o.versionGuid.Set(v) +} + +// InstanceGuid returns the value of the instanceGuid property. +func (o *MsdMetadata) InstanceGuid() string { + return o.instanceGuid.Get() +} + +// SetInstanceGuid sets the value of the instanceGuid property. +func (o *MsdMetadata) SetInstanceGuid(v string) { + o.instanceGuid.Set(v) +} + +// SupportedProtocols returns the value of the supportedProtocols property. +func (o *MsdMetadata) SupportedProtocols() string { + return o.supportedProtocols.Get() +} + +// HeaderAuthentication returns the value of the headerAuthentication property. +func (o *MsdMetadata) HeaderAuthentication() string { + return o.headerAuthentication.Get() +} + +// SetHeaderAuthentication sets the value of the headerAuthentication property. +func (o *MsdMetadata) SetHeaderAuthentication(v string) { + o.headerAuthentication.Set(v) +} + +// MicroflowsItems returns the value of the microflows property. +func (o *MsdMetadata) MicroflowsItems() []element.Element { + return o.microflows.Items() +} + +// AddMicroflows appends a child element to the microflows list. +func (o *MsdMetadata) AddMicroflows(v element.Element) { + o.microflows.Append(v) +} + +// RemoveMicroflows removes the element at the given index from the microflows list. +func (o *MsdMetadata) RemoveMicroflows(index int) { + o.microflows.Remove(index) +} + +// Caption returns the value of the caption property. +func (o *MsdMetadata) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *MsdMetadata) SetCaption(v string) { + o.caption.Set(v) +} + +// Image returns the value of the image property. +func (o *MsdMetadata) Image() string { + return o.image.Get() +} + +// SetImage sets the value of the image property. +func (o *MsdMetadata) SetImage(v string) { + o.image.Set(v) +} + +// Description returns the value of the description property. +func (o *MsdMetadata) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *MsdMetadata) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdMetadata) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.version.Init(raw) + o.publishDateTime.Init(raw) + o.serviceGuid.Init(raw) + o.versionGuid.Init(raw) + o.instanceGuid.Init(raw) + o.supportedProtocols.Init(raw) + o.headerAuthentication.Init(raw) + if children, err := codec.DecodeChildren(raw, "Microflows"); err == nil { + for _, child := range children { + o.microflows.AppendFromDecode(child) + } + } + o.caption.Init(raw) + o.image.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MsdMicroflow +// ──────────────────────────────────────────────────────── + +type MsdMicroflow struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + image *property.Primitive[string] + description *property.Primitive[string] + parameters *property.PartList[element.Element] + returnType *property.Primitive[string] + systemEntityType *property.Primitive[string] + returnTypeSpecification *property.Primitive[string] + returnTypeCanBeEmpty *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *MsdMicroflow) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MsdMicroflow) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MsdMicroflow) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MsdMicroflow) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Image returns the value of the image property. +func (o *MsdMicroflow) Image() string { + return o.image.Get() +} + +// SetImage sets the value of the image property. +func (o *MsdMicroflow) SetImage(v string) { + o.image.Set(v) +} + +// Description returns the value of the description property. +func (o *MsdMicroflow) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *MsdMicroflow) SetDescription(v string) { + o.description.Set(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *MsdMicroflow) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *MsdMicroflow) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *MsdMicroflow) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// ReturnType returns the value of the returnType property. +func (o *MsdMicroflow) ReturnType() string { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *MsdMicroflow) SetReturnType(v string) { + o.returnType.Set(v) +} + +// SystemEntityType returns the value of the systemEntityType property. +func (o *MsdMicroflow) SystemEntityType() string { + return o.systemEntityType.Get() +} + +// SetSystemEntityType sets the value of the systemEntityType property. +func (o *MsdMicroflow) SetSystemEntityType(v string) { + o.systemEntityType.Set(v) +} + +// ReturnTypeSpecification returns the value of the returnTypeSpecification property. +func (o *MsdMicroflow) ReturnTypeSpecification() string { + return o.returnTypeSpecification.Get() +} + +// SetReturnTypeSpecification sets the value of the returnTypeSpecification property. +func (o *MsdMicroflow) SetReturnTypeSpecification(v string) { + o.returnTypeSpecification.Set(v) +} + +// ReturnTypeCanBeEmpty returns the value of the returnTypeCanBeEmpty property. +func (o *MsdMicroflow) ReturnTypeCanBeEmpty() bool { + return o.returnTypeCanBeEmpty.Get() +} + +// SetReturnTypeCanBeEmpty sets the value of the returnTypeCanBeEmpty property. +func (o *MsdMicroflow) SetReturnTypeCanBeEmpty(v bool) { + o.returnTypeCanBeEmpty.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdMicroflow) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.image.Init(raw) + o.description.Init(raw) + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + o.returnType.Init(raw) + o.systemEntityType.Init(raw) + o.returnTypeSpecification.Init(raw) + o.returnTypeCanBeEmpty.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MsdMicroflowParameter +// ──────────────────────────────────────────────────────── + +type MsdMicroflowParameter struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + typeSpecification *property.Primitive[string] + systemEntityType *property.Primitive[string] + canBeEmpty *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *MsdMicroflowParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MsdMicroflowParameter) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *MsdMicroflowParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *MsdMicroflowParameter) SetType(v string) { + o.propType.Set(v) +} + +// TypeSpecification returns the value of the typeSpecification property. +func (o *MsdMicroflowParameter) TypeSpecification() string { + return o.typeSpecification.Get() +} + +// SetTypeSpecification sets the value of the typeSpecification property. +func (o *MsdMicroflowParameter) SetTypeSpecification(v string) { + o.typeSpecification.Set(v) +} + +// SystemEntityType returns the value of the systemEntityType property. +func (o *MsdMicroflowParameter) SystemEntityType() string { + return o.systemEntityType.Get() +} + +// SetSystemEntityType sets the value of the systemEntityType property. +func (o *MsdMicroflowParameter) SetSystemEntityType(v string) { + o.systemEntityType.Set(v) +} + +// CanBeEmpty returns the value of the canBeEmpty property. +func (o *MsdMicroflowParameter) CanBeEmpty() bool { + return o.canBeEmpty.Get() +} + +// SetCanBeEmpty sets the value of the canBeEmpty property. +func (o *MsdMicroflowParameter) SetCanBeEmpty(v bool) { + o.canBeEmpty.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdMicroflowParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + o.typeSpecification.Init(raw) + o.systemEntityType.Init(raw) + o.canBeEmpty.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MsdText +// ──────────────────────────────────────────────────────── + +type MsdText struct { + element.Base + languageCode *property.Primitive[string] + caption *property.Primitive[string] +} + +// LanguageCode returns the value of the languageCode property. +func (o *MsdText) LanguageCode() string { + return o.languageCode.Get() +} + +// SetLanguageCode sets the value of the languageCode property. +func (o *MsdText) SetLanguageCode(v string) { + o.languageCode.Set(v) +} + +// Caption returns the value of the caption property. +func (o *MsdText) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *MsdText) SetCaption(v string) { + o.caption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdText) InitFromRaw(raw bson.Raw) { + o.languageCode.Init(raw) + o.caption.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MsdVersion +// ──────────────────────────────────────────────────────── + +type MsdVersion struct { + element.Base + version *property.Primitive[int32] +} + +// Version returns the value of the version property. +func (o *MsdVersion) Version() int32 { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *MsdVersion) SetVersion(v int32) { + o.version.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MsdVersion) InitFromRaw(raw bson.Raw) { + o.version.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initAppServiceAction creates a AppServiceAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAppServiceAction() *AppServiceAction { + o := &AppServiceAction{} + o.SetTypeName("AppServices$AppServiceAction") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 3) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 4) + o.returnType = property.NewPrimitive[string]("ReturnType", property.DecodeString) + o.returnType.Bind(&o.Base, 5) + o.actionReturnType = property.NewPart[element.Element]("ActionReturnType") + o.actionReturnType.Bind(&o.Base, 6) + o.returnTypeCanBeEmpty = property.NewPrimitive[bool]("ReturnTypeCanBeEmpty", property.DecodeBool) + o.returnTypeCanBeEmpty.Bind(&o.Base, 7) + o.image = property.NewPrimitive[string]("Image", property.DecodeString) + o.image.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.caption, o.description, o.parameters, o.microflow, o.returnType, o.actionReturnType, o.returnTypeCanBeEmpty, o.image}) + return o +} + +// NewAppServiceAction creates a new AppServiceAction for user code. Marked dirty (bit 63 = new element). +func NewAppServiceAction() *AppServiceAction { + o := initAppServiceAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAppServiceActionParameter creates a AppServiceActionParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAppServiceActionParameter() *AppServiceActionParameter { + o := &AppServiceActionParameter{} + o.SetTypeName("AppServices$AppServiceActionParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 1) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 2) + o.canBeEmpty = property.NewPrimitive[bool]("CanBeEmpty", property.DecodeBool) + o.canBeEmpty.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.name, o.propType, o.parameterType, o.canBeEmpty}) + return o +} + +// NewAppServiceActionParameter creates a new AppServiceActionParameter for user code. Marked dirty (bit 63 = new element). +func NewAppServiceActionParameter() *AppServiceActionParameter { + o := initAppServiceActionParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConsumedAppService creates a ConsumedAppService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConsumedAppService() *ConsumedAppService { + o := &ConsumedAppService{} + o.SetTypeName("AppServices$ConsumedAppService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.actions = property.NewPartList[element.Element]("Actions") + o.actions.Bind(&o.Base, 4) + o.msd = property.NewPart[element.Element]("Msd") + o.msd.Bind(&o.Base, 5) + o.fromAppStore = property.NewPrimitive[bool]("FromAppStore", property.DecodeBool) + o.fromAppStore.Bind(&o.Base, 6) + o.appStoreGuid = property.NewPrimitive[string]("AppStoreGuid", property.DecodeString) + o.appStoreGuid.Bind(&o.Base, 7) + o.appStoreVersionGuid = property.NewPrimitive[string]("AppStoreVersionGuid", property.DecodeString) + o.appStoreVersionGuid.Bind(&o.Base, 8) + o.appStoreVersion = property.NewPrimitive[string]("AppStoreVersion", property.DecodeString) + o.appStoreVersion.Bind(&o.Base, 9) + o.appServiceLocation = property.NewEnum[string]("AppServiceLocation") + o.appServiceLocation.Bind(&o.Base, 10) + o.locationConstant = property.NewByNameRef[element.Element]("LocationConstant", "Constants$Constant") + o.locationConstant.Bind(&o.Base, 11) + o.useTimeOut = property.NewPrimitive[bool]("UseTimeOut", property.DecodeBool) + o.useTimeOut.Bind(&o.Base, 12) + o.timeOut = property.NewPrimitive[int32]("TimeOut", property.DecodeInt32) + o.timeOut.Bind(&o.Base, 13) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.actions, o.msd, o.fromAppStore, o.appStoreGuid, o.appStoreVersionGuid, o.appStoreVersion, o.appServiceLocation, o.locationConstant, o.useTimeOut, o.timeOut}) + return o +} + +// NewConsumedAppService creates a new ConsumedAppService for user code. Marked dirty (bit 63 = new element). +func NewConsumedAppService() *ConsumedAppService { + o := initConsumedAppService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsd creates a Msd with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsd() *Msd { + o := &Msd{} + o.SetTypeName("AppServices$Msd") + o.version = property.NewPart[element.Element]("Version") + o.version.Bind(&o.Base, 0) + o.metadata = property.NewPart[element.Element]("Metadata") + o.metadata.Bind(&o.Base, 1) + o.domainModel = property.NewPart[element.Element]("DomainModel") + o.domainModel.Bind(&o.Base, 2) + o.enumerations = property.NewPart[element.Element]("Enumerations") + o.enumerations.Bind(&o.Base, 3) + o.wsdlDescription = property.NewPart[element.Element]("WsdlDescription") + o.wsdlDescription.Bind(&o.Base, 4) + o.wsdl = property.NewPrimitive[string]("Wsdl", property.DecodeString) + o.wsdl.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.version, o.metadata, o.domainModel, o.enumerations, o.wsdlDescription, o.wsdl}) + return o +} + +// NewMsd creates a new Msd for user code. Marked dirty (bit 63 = new element). +func NewMsd() *Msd { + o := initMsd() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdAssociation creates a MsdAssociation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdAssociation() *MsdAssociation { + o := &MsdAssociation{} + o.SetTypeName("AppServices$MsdAssociation") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.guid = property.NewPrimitive[string]("Guid", property.DecodeString) + o.guid.Bind(&o.Base, 1) + o.parentEntityName = property.NewPrimitive[string]("ParentEntityName", property.DecodeString) + o.parentEntityName.Bind(&o.Base, 2) + o.childEntityName = property.NewPrimitive[string]("ChildEntityName", property.DecodeString) + o.childEntityName.Bind(&o.Base, 3) + o.associationType = property.NewPrimitive[string]("AssociationType", property.DecodeString) + o.associationType.Bind(&o.Base, 4) + o.associationOwner = property.NewPrimitive[string]("AssociationOwner", property.DecodeString) + o.associationOwner.Bind(&o.Base, 5) + o.parentDeleteBehavior = property.NewPrimitive[string]("ParentDeleteBehavior", property.DecodeString) + o.parentDeleteBehavior.Bind(&o.Base, 6) + o.childDeleteBehavior = property.NewPrimitive[string]("ChildDeleteBehavior", property.DecodeString) + o.childDeleteBehavior.Bind(&o.Base, 7) + o.associationKind = property.NewPrimitive[string]("AssociationKind", property.DecodeString) + o.associationKind.Bind(&o.Base, 8) + o.parentX = property.NewPrimitive[int32]("ParentX", property.DecodeInt32) + o.parentX.Bind(&o.Base, 9) + o.parentY = property.NewPrimitive[int32]("ParentY", property.DecodeInt32) + o.parentY.Bind(&o.Base, 10) + o.childX = property.NewPrimitive[int32]("ChildX", property.DecodeInt32) + o.childX.Bind(&o.Base, 11) + o.childY = property.NewPrimitive[int32]("ChildY", property.DecodeInt32) + o.childY.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.guid, o.parentEntityName, o.childEntityName, o.associationType, o.associationOwner, o.parentDeleteBehavior, o.childDeleteBehavior, o.associationKind, o.parentX, o.parentY, o.childX, o.childY}) + return o +} + +// NewMsdAssociation creates a new MsdAssociation for user code. Marked dirty (bit 63 = new element). +func NewMsdAssociation() *MsdAssociation { + o := initMsdAssociation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdAttribute creates a MsdAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdAttribute() *MsdAttribute { + o := &MsdAttribute{} + o.SetTypeName("AppServices$MsdAttribute") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.guid = property.NewPrimitive[string]("Guid", property.DecodeString) + o.guid.Bind(&o.Base, 1) + o.attributeType = property.NewPrimitive[string]("AttributeType", property.DecodeString) + o.attributeType.Bind(&o.Base, 2) + o.enumerationName = property.NewPrimitive[string]("EnumerationName", property.DecodeString) + o.enumerationName.Bind(&o.Base, 3) + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 4) + o.length = property.NewPrimitive[int32]("Length", property.DecodeInt32) + o.length.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.guid, o.attributeType, o.enumerationName, o.defaultValue, o.length}) + return o +} + +// NewMsdAttribute creates a new MsdAttribute for user code. Marked dirty (bit 63 = new element). +func NewMsdAttribute() *MsdAttribute { + o := initMsdAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdDomainModel creates a MsdDomainModel with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdDomainModel() *MsdDomainModel { + o := &MsdDomainModel{} + o.SetTypeName("AppServices$MsdDomainModel") + o.entities = property.NewPartList[element.Element]("Entities") + o.entities.Bind(&o.Base, 0) + o.associations = property.NewPartList[element.Element]("Associations") + o.associations.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.entities, o.associations}) + return o +} + +// NewMsdDomainModel creates a new MsdDomainModel for user code. Marked dirty (bit 63 = new element). +func NewMsdDomainModel() *MsdDomainModel { + o := initMsdDomainModel() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdEntity creates a MsdEntity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdEntity() *MsdEntity { + o := &MsdEntity{} + o.SetTypeName("AppServices$MsdEntity") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.guid = property.NewPrimitive[string]("Guid", property.DecodeString) + o.guid.Bind(&o.Base, 1) + o.generalizationName = property.NewPrimitive[string]("GeneralizationName", property.DecodeString) + o.generalizationName.Bind(&o.Base, 2) + o.persistable = property.NewPrimitive[bool]("Persistable", property.DecodeBool) + o.persistable.Bind(&o.Base, 3) + o.locationX = property.NewPrimitive[int32]("LocationX", property.DecodeInt32) + o.locationX.Bind(&o.Base, 4) + o.locationY = property.NewPrimitive[int32]("LocationY", property.DecodeInt32) + o.locationY.Bind(&o.Base, 5) + o.attributes = property.NewPartList[element.Element]("Attributes") + o.attributes.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.guid, o.generalizationName, o.persistable, o.locationX, o.locationY, o.attributes}) + return o +} + +// NewMsdEntity creates a new MsdEntity for user code. Marked dirty (bit 63 = new element). +func NewMsdEntity() *MsdEntity { + o := initMsdEntity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdEnumeration creates a MsdEnumeration with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdEnumeration() *MsdEnumeration { + o := &MsdEnumeration{} + o.SetTypeName("AppServices$MsdEnumeration") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.guid = property.NewPrimitive[string]("Guid", property.DecodeString) + o.guid.Bind(&o.Base, 1) + o.values = property.NewPartList[element.Element]("Values") + o.values.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.guid, o.values}) + return o +} + +// NewMsdEnumeration creates a new MsdEnumeration for user code. Marked dirty (bit 63 = new element). +func NewMsdEnumeration() *MsdEnumeration { + o := initMsdEnumeration() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdEnumerationContainer creates a MsdEnumerationContainer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdEnumerationContainer() *MsdEnumerationContainer { + o := &MsdEnumerationContainer{} + o.SetTypeName("AppServices$MsdEnumerationContainer") + o.enumerations = property.NewPartList[element.Element]("Enumerations") + o.enumerations.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.enumerations}) + return o +} + +// NewMsdEnumerationContainer creates a new MsdEnumerationContainer for user code. Marked dirty (bit 63 = new element). +func NewMsdEnumerationContainer() *MsdEnumerationContainer { + o := initMsdEnumerationContainer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdEnumerationValue creates a MsdEnumerationValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdEnumerationValue() *MsdEnumerationValue { + o := &MsdEnumerationValue{} + o.SetTypeName("AppServices$MsdEnumerationValue") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.guid = property.NewPrimitive[string]("Guid", property.DecodeString) + o.guid.Bind(&o.Base, 1) + o.translations = property.NewPartList[element.Element]("Translations") + o.translations.Bind(&o.Base, 2) + o.image = property.NewPrimitive[string]("Image", property.DecodeString) + o.image.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.name, o.guid, o.translations, o.image}) + return o +} + +// NewMsdEnumerationValue creates a new MsdEnumerationValue for user code. Marked dirty (bit 63 = new element). +func NewMsdEnumerationValue() *MsdEnumerationValue { + o := initMsdEnumerationValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdMetadata creates a MsdMetadata with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdMetadata() *MsdMetadata { + o := &MsdMetadata{} + o.SetTypeName("AppServices$MsdMetadata") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.version = property.NewPrimitive[int32]("Version", property.DecodeInt32) + o.version.Bind(&o.Base, 2) + o.publishDateTime = property.NewPrimitive[string]("PublishDateTime", property.DecodeString) + o.publishDateTime.Bind(&o.Base, 3) + o.serviceGuid = property.NewPrimitive[string]("ServiceGuid", property.DecodeString) + o.serviceGuid.Bind(&o.Base, 4) + o.versionGuid = property.NewPrimitive[string]("VersionGuid", property.DecodeString) + o.versionGuid.Bind(&o.Base, 5) + o.instanceGuid = property.NewPrimitive[string]("InstanceGuid", property.DecodeString) + o.instanceGuid.Bind(&o.Base, 6) + o.supportedProtocols = property.NewPrimitive[string]("SupportedProtocols", property.DecodeString) + o.supportedProtocols.Bind(&o.Base, 7) + o.headerAuthentication = property.NewPrimitive[string]("HeaderAuthentication", property.DecodeString) + o.headerAuthentication.Bind(&o.Base, 8) + o.microflows = property.NewPartList[element.Element]("Microflows") + o.microflows.Bind(&o.Base, 9) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 10) + o.image = property.NewPrimitive[string]("Image", property.DecodeString) + o.image.Bind(&o.Base, 11) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.documentation, o.version, o.publishDateTime, o.serviceGuid, o.versionGuid, o.instanceGuid, o.supportedProtocols, o.headerAuthentication, o.microflows, o.caption, o.image, o.description}) + return o +} + +// NewMsdMetadata creates a new MsdMetadata for user code. Marked dirty (bit 63 = new element). +func NewMsdMetadata() *MsdMetadata { + o := initMsdMetadata() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdMicroflow creates a MsdMicroflow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdMicroflow() *MsdMicroflow { + o := &MsdMicroflow{} + o.SetTypeName("AppServices$MsdMicroflow") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.image = property.NewPrimitive[string]("Image", property.DecodeString) + o.image.Bind(&o.Base, 2) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 3) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 4) + o.returnType = property.NewPrimitive[string]("ReturnType", property.DecodeString) + o.returnType.Bind(&o.Base, 5) + o.systemEntityType = property.NewPrimitive[string]("SystemEntityType", property.DecodeString) + o.systemEntityType.Bind(&o.Base, 6) + o.returnTypeSpecification = property.NewPrimitive[string]("ReturnTypeSpecification", property.DecodeString) + o.returnTypeSpecification.Bind(&o.Base, 7) + o.returnTypeCanBeEmpty = property.NewPrimitive[bool]("ReturnTypeCanBeEmpty", property.DecodeBool) + o.returnTypeCanBeEmpty.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.documentation, o.image, o.description, o.parameters, o.returnType, o.systemEntityType, o.returnTypeSpecification, o.returnTypeCanBeEmpty}) + return o +} + +// NewMsdMicroflow creates a new MsdMicroflow for user code. Marked dirty (bit 63 = new element). +func NewMsdMicroflow() *MsdMicroflow { + o := initMsdMicroflow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdMicroflowParameter creates a MsdMicroflowParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdMicroflowParameter() *MsdMicroflowParameter { + o := &MsdMicroflowParameter{} + o.SetTypeName("AppServices$MsdMicroflowParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 1) + o.typeSpecification = property.NewPrimitive[string]("TypeSpecification", property.DecodeString) + o.typeSpecification.Bind(&o.Base, 2) + o.systemEntityType = property.NewPrimitive[string]("SystemEntityType", property.DecodeString) + o.systemEntityType.Bind(&o.Base, 3) + o.canBeEmpty = property.NewPrimitive[bool]("CanBeEmpty", property.DecodeBool) + o.canBeEmpty.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.propType, o.typeSpecification, o.systemEntityType, o.canBeEmpty}) + return o +} + +// NewMsdMicroflowParameter creates a new MsdMicroflowParameter for user code. Marked dirty (bit 63 = new element). +func NewMsdMicroflowParameter() *MsdMicroflowParameter { + o := initMsdMicroflowParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdText creates a MsdText with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdText() *MsdText { + o := &MsdText{} + o.SetTypeName("AppServices$MsdText") + o.languageCode = property.NewPrimitive[string]("LanguageCode", property.DecodeString) + o.languageCode.Bind(&o.Base, 0) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.languageCode, o.caption}) + return o +} + +// NewMsdText creates a new MsdText for user code. Marked dirty (bit 63 = new element). +func NewMsdText() *MsdText { + o := initMsdText() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMsdVersion creates a MsdVersion with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMsdVersion() *MsdVersion { + o := &MsdVersion{} + o.SetTypeName("AppServices$MsdVersion") + o.version = property.NewPrimitive[int32]("Version", property.DecodeInt32) + o.version.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.version}) + return o +} + +// NewMsdVersion creates a new MsdVersion for user code. Marked dirty (bit 63 = new element). +func NewMsdVersion() *MsdVersion { + o := initMsdVersion() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("AppServices$AppServiceAction", func() element.Element { + return initAppServiceAction() + }) + codec.DefaultRegistry.Register("AppServices$AppServiceActionParameter", func() element.Element { + return initAppServiceActionParameter() + }) + codec.DefaultRegistry.Register("AppServices$ConsumedAppService", func() element.Element { + return initConsumedAppService() + }) + codec.DefaultRegistry.Register("AppServices$Msd", func() element.Element { + return initMsd() + }) + codec.DefaultRegistry.Register("AppServices$MsdAssociation", func() element.Element { + return initMsdAssociation() + }) + codec.DefaultRegistry.Register("AppServices$MsdAttribute", func() element.Element { + return initMsdAttribute() + }) + codec.DefaultRegistry.Register("AppServices$MsdDomainModel", func() element.Element { + return initMsdDomainModel() + }) + codec.DefaultRegistry.Register("AppServices$MsdEntity", func() element.Element { + return initMsdEntity() + }) + codec.DefaultRegistry.Register("AppServices$MsdEnumeration", func() element.Element { + return initMsdEnumeration() + }) + codec.DefaultRegistry.Register("AppServices$MsdEnumerationContainer", func() element.Element { + return initMsdEnumerationContainer() + }) + codec.DefaultRegistry.Register("AppServices$MsdEnumerationValue", func() element.Element { + return initMsdEnumerationValue() + }) + codec.DefaultRegistry.Register("AppServices$MsdMetadata", func() element.Element { + return initMsdMetadata() + }) + codec.DefaultRegistry.Register("AppServices$MsdMicroflow", func() element.Element { + return initMsdMicroflow() + }) + codec.DefaultRegistry.Register("AppServices$MsdMicroflowParameter", func() element.Element { + return initMsdMicroflowParameter() + }) + codec.DefaultRegistry.Register("AppServices$MsdText", func() element.Element { + return initMsdText() + }) + codec.DefaultRegistry.Register("AppServices$MsdVersion", func() element.Element { + return initMsdVersion() + }) +} diff --git a/modelsdk/gen/appservices/version.go b/modelsdk/gen/appservices/version.go new file mode 100644 index 00000000..7866948d --- /dev/null +++ b/modelsdk/gen/appservices/version.go @@ -0,0 +1,51 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package appservices + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "AppServices$AppServiceAction": { + Properties: map[string]version.PropertyVersionInfo{ + "actionReturnType": {Introduced: "7.9.0", Required: true}, + "name": {Public: true}, + "parameters": {Public: true}, + "returnType": {Deleted: "7.9.0"}, + }, + }, + "AppServices$AppServiceActionParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "parameterType": {Introduced: "7.9.0", Required: true}, + "type": {Deleted: "7.9.0"}, + }, + }, + "AppServices$ConsumedAppService": { + Properties: map[string]version.PropertyVersionInfo{ + "actions": {Public: true}, + "msd": {Required: true}, + }, + }, + "AppServices$Msd": { + Properties: map[string]version.PropertyVersionInfo{ + "domainModel": {Required: true}, + "enumerations": {Required: true}, + "metadata": {Required: true}, + "version": {Required: true}, + "wsdlDescription": {Required: true}, + }, + }, + "AppServices$MsdMicroflow": { + Properties: map[string]version.PropertyVersionInfo{ + "systemEntityType": {Deleted: "6.1.0"}, + }, + }, + "AppServices$MsdMicroflowParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "systemEntityType": {Deleted: "6.1.0"}, + }, + }, +} diff --git a/modelsdk/gen/authentication/enums.go b/modelsdk/gen/authentication/enums.go new file mode 100644 index 00000000..89d59282 --- /dev/null +++ b/modelsdk/gen/authentication/enums.go @@ -0,0 +1,23 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package authentication + +// AuthenticationMethod enumerates the possible values for the AuthenticationMethod type. +type AuthenticationMethod = string + +const ( + AuthenticationMethodUnknown AuthenticationMethod = "Unknown" + AuthenticationMethodBasic AuthenticationMethod = "Basic" + AuthenticationMethodOAuth20 AuthenticationMethod = "OAuth20" +) + +// GrantType enumerates the possible values for the GrantType type. +type GrantType = string + +const ( + GrantTypeUnknown GrantType = "Unknown" + GrantTypeAuthorizationCode GrantType = "AuthorizationCode" + GrantTypeClientCredentials GrantType = "ClientCredentials" +) diff --git a/modelsdk/gen/authentication/refs.go b/modelsdk/gen/authentication/refs.go new file mode 100644 index 00000000..89ce92c7 --- /dev/null +++ b/modelsdk/gen/authentication/refs.go @@ -0,0 +1,34 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package authentication + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Authentication$BasicAuthenticationDetails", []codec.RefMeta{ + {Prop: "Username", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "Password", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Authentication$OAuth20AuthenticationDetails", []codec.RefMeta{ + {Prop: "TenantId", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "ClientId", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "ClientSecret", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "TokenEndPoint", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Authentication$OAuth20AuthCodeDetails", []codec.RefMeta{ + {Prop: "TenantId", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "ClientId", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "ClientSecret", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "TokenEndPoint", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "AuthorizationEndpoint", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "CallbackUrl", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Authentication$OAuth20ClientCredentialsDetails", []codec.RefMeta{ + {Prop: "TenantId", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "ClientId", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "ClientSecret", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "TokenEndPoint", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) +} diff --git a/modelsdk/gen/authentication/types.go b/modelsdk/gen/authentication/types.go new file mode 100644 index 00000000..3f008508 --- /dev/null +++ b/modelsdk/gen/authentication/types.go @@ -0,0 +1,768 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package authentication + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Authentication +// ──────────────────────────────────────────────────────── + +type Authentication struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + authenticationDetails *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *Authentication) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Authentication) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Authentication) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Authentication) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Authentication) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Authentication) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Authentication) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Authentication) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// AuthenticationDetails returns the value of the authenticationDetails property. +func (o *Authentication) AuthenticationDetails() element.Element { + return o.authenticationDetails.Get() +} + +// SetAuthenticationDetails sets the value of the authenticationDetails property. +func (o *Authentication) SetAuthenticationDetails(v element.Element) { + o.authenticationDetails.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Authentication) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "AuthenticationDetails"); err == nil { + o.authenticationDetails.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// AuthenticationDetails +// ──────────────────────────────────────────────────────── + +type AuthenticationDetails struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AuthenticationDetails) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BasicAuthenticationDetails +// ──────────────────────────────────────────────────────── + +type BasicAuthenticationDetails struct { + element.Base + username *property.ByNameRef[element.Element] + password *property.ByNameRef[element.Element] +} + +// UsernameQualifiedName returns the value of the username property. +func (o *BasicAuthenticationDetails) UsernameQualifiedName() string { + return o.username.QualifiedName() +} + +// SetUsernameQualifiedName sets the value of the username property. +func (o *BasicAuthenticationDetails) SetUsernameQualifiedName(v string) { + o.username.SetQualifiedName(v) +} + +// PasswordQualifiedName returns the value of the password property. +func (o *BasicAuthenticationDetails) PasswordQualifiedName() string { + return o.password.QualifiedName() +} + +// SetPasswordQualifiedName sets the value of the password property. +func (o *BasicAuthenticationDetails) SetPasswordQualifiedName(v string) { + o.password.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicAuthenticationDetails) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Username"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.username.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Password"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.password.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// OAuth20AuthenticationDetails +// ──────────────────────────────────────────────────────── + +type OAuth20AuthenticationDetails struct { + element.Base + providerName *property.Primitive[string] + wellKnownEndPoint *property.Primitive[string] + tenantId *property.ByNameRef[element.Element] + clientId *property.ByNameRef[element.Element] + clientSecret *property.ByNameRef[element.Element] + tokenEndPoint *property.ByNameRef[element.Element] + scopes *property.Primitive[string] + grantType *property.Enum[string] + audience *property.Primitive[string] +} + +// ProviderName returns the value of the providerName property. +func (o *OAuth20AuthenticationDetails) ProviderName() string { + return o.providerName.Get() +} + +// SetProviderName sets the value of the providerName property. +func (o *OAuth20AuthenticationDetails) SetProviderName(v string) { + o.providerName.Set(v) +} + +// WellKnownEndPoint returns the value of the wellKnownEndPoint property. +func (o *OAuth20AuthenticationDetails) WellKnownEndPoint() string { + return o.wellKnownEndPoint.Get() +} + +// SetWellKnownEndPoint sets the value of the wellKnownEndPoint property. +func (o *OAuth20AuthenticationDetails) SetWellKnownEndPoint(v string) { + o.wellKnownEndPoint.Set(v) +} + +// TenantIdQualifiedName returns the value of the tenantId property. +func (o *OAuth20AuthenticationDetails) TenantIdQualifiedName() string { + return o.tenantId.QualifiedName() +} + +// SetTenantIdQualifiedName sets the value of the tenantId property. +func (o *OAuth20AuthenticationDetails) SetTenantIdQualifiedName(v string) { + o.tenantId.SetQualifiedName(v) +} + +// ClientIdQualifiedName returns the value of the clientId property. +func (o *OAuth20AuthenticationDetails) ClientIdQualifiedName() string { + return o.clientId.QualifiedName() +} + +// SetClientIdQualifiedName sets the value of the clientId property. +func (o *OAuth20AuthenticationDetails) SetClientIdQualifiedName(v string) { + o.clientId.SetQualifiedName(v) +} + +// ClientSecretQualifiedName returns the value of the clientSecret property. +func (o *OAuth20AuthenticationDetails) ClientSecretQualifiedName() string { + return o.clientSecret.QualifiedName() +} + +// SetClientSecretQualifiedName sets the value of the clientSecret property. +func (o *OAuth20AuthenticationDetails) SetClientSecretQualifiedName(v string) { + o.clientSecret.SetQualifiedName(v) +} + +// TokenEndPointQualifiedName returns the value of the tokenEndPoint property. +func (o *OAuth20AuthenticationDetails) TokenEndPointQualifiedName() string { + return o.tokenEndPoint.QualifiedName() +} + +// SetTokenEndPointQualifiedName sets the value of the tokenEndPoint property. +func (o *OAuth20AuthenticationDetails) SetTokenEndPointQualifiedName(v string) { + o.tokenEndPoint.SetQualifiedName(v) +} + +// Scopes returns the value of the scopes property. +func (o *OAuth20AuthenticationDetails) Scopes() string { + return o.scopes.Get() +} + +// GrantType returns the value of the grantType property. +func (o *OAuth20AuthenticationDetails) GrantType() string { + return o.grantType.Get() +} + +// SetGrantType sets the value of the grantType property. +func (o *OAuth20AuthenticationDetails) SetGrantType(v string) { + o.grantType.Set(v) +} + +// Audience returns the value of the audience property. +func (o *OAuth20AuthenticationDetails) Audience() string { + return o.audience.Get() +} + +// SetAudience sets the value of the audience property. +func (o *OAuth20AuthenticationDetails) SetAudience(v string) { + o.audience.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OAuth20AuthenticationDetails) InitFromRaw(raw bson.Raw) { + o.providerName.Init(raw) + o.wellKnownEndPoint.Init(raw) + if val, err := raw.LookupErr("TenantId"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.tenantId.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ClientId"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.clientId.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ClientSecret"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.clientSecret.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("TokenEndPoint"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.tokenEndPoint.SetFromDecode(s) + } + } + o.scopes.Init(raw) + if val, err := raw.LookupErr("GrantType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.grantType.SetFromDecode(s) + } + } + o.audience.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OAuth20AuthCodeDetails +// ──────────────────────────────────────────────────────── + +type OAuth20AuthCodeDetails struct { + element.Base + providerName *property.Primitive[string] + wellKnownEndPoint *property.Primitive[string] + tenantId *property.ByNameRef[element.Element] + clientId *property.ByNameRef[element.Element] + clientSecret *property.ByNameRef[element.Element] + tokenEndPoint *property.ByNameRef[element.Element] + scopes *property.Primitive[string] + grantType *property.Enum[string] + audience *property.Primitive[string] + responseType *property.Primitive[string] + responseMode *property.Primitive[string] + authorizationEndpoint *property.ByNameRef[element.Element] + callbackUrl *property.ByNameRef[element.Element] +} + +// ProviderName returns the value of the providerName property. +func (o *OAuth20AuthCodeDetails) ProviderName() string { + return o.providerName.Get() +} + +// SetProviderName sets the value of the providerName property. +func (o *OAuth20AuthCodeDetails) SetProviderName(v string) { + o.providerName.Set(v) +} + +// WellKnownEndPoint returns the value of the wellKnownEndPoint property. +func (o *OAuth20AuthCodeDetails) WellKnownEndPoint() string { + return o.wellKnownEndPoint.Get() +} + +// SetWellKnownEndPoint sets the value of the wellKnownEndPoint property. +func (o *OAuth20AuthCodeDetails) SetWellKnownEndPoint(v string) { + o.wellKnownEndPoint.Set(v) +} + +// TenantIdQualifiedName returns the value of the tenantId property. +func (o *OAuth20AuthCodeDetails) TenantIdQualifiedName() string { + return o.tenantId.QualifiedName() +} + +// SetTenantIdQualifiedName sets the value of the tenantId property. +func (o *OAuth20AuthCodeDetails) SetTenantIdQualifiedName(v string) { + o.tenantId.SetQualifiedName(v) +} + +// ClientIdQualifiedName returns the value of the clientId property. +func (o *OAuth20AuthCodeDetails) ClientIdQualifiedName() string { + return o.clientId.QualifiedName() +} + +// SetClientIdQualifiedName sets the value of the clientId property. +func (o *OAuth20AuthCodeDetails) SetClientIdQualifiedName(v string) { + o.clientId.SetQualifiedName(v) +} + +// ClientSecretQualifiedName returns the value of the clientSecret property. +func (o *OAuth20AuthCodeDetails) ClientSecretQualifiedName() string { + return o.clientSecret.QualifiedName() +} + +// SetClientSecretQualifiedName sets the value of the clientSecret property. +func (o *OAuth20AuthCodeDetails) SetClientSecretQualifiedName(v string) { + o.clientSecret.SetQualifiedName(v) +} + +// TokenEndPointQualifiedName returns the value of the tokenEndPoint property. +func (o *OAuth20AuthCodeDetails) TokenEndPointQualifiedName() string { + return o.tokenEndPoint.QualifiedName() +} + +// SetTokenEndPointQualifiedName sets the value of the tokenEndPoint property. +func (o *OAuth20AuthCodeDetails) SetTokenEndPointQualifiedName(v string) { + o.tokenEndPoint.SetQualifiedName(v) +} + +// Scopes returns the value of the scopes property. +func (o *OAuth20AuthCodeDetails) Scopes() string { + return o.scopes.Get() +} + +// GrantType returns the value of the grantType property. +func (o *OAuth20AuthCodeDetails) GrantType() string { + return o.grantType.Get() +} + +// SetGrantType sets the value of the grantType property. +func (o *OAuth20AuthCodeDetails) SetGrantType(v string) { + o.grantType.Set(v) +} + +// Audience returns the value of the audience property. +func (o *OAuth20AuthCodeDetails) Audience() string { + return o.audience.Get() +} + +// SetAudience sets the value of the audience property. +func (o *OAuth20AuthCodeDetails) SetAudience(v string) { + o.audience.Set(v) +} + +// ResponseType returns the value of the responseType property. +func (o *OAuth20AuthCodeDetails) ResponseType() string { + return o.responseType.Get() +} + +// SetResponseType sets the value of the responseType property. +func (o *OAuth20AuthCodeDetails) SetResponseType(v string) { + o.responseType.Set(v) +} + +// ResponseMode returns the value of the responseMode property. +func (o *OAuth20AuthCodeDetails) ResponseMode() string { + return o.responseMode.Get() +} + +// SetResponseMode sets the value of the responseMode property. +func (o *OAuth20AuthCodeDetails) SetResponseMode(v string) { + o.responseMode.Set(v) +} + +// AuthorizationEndpointQualifiedName returns the value of the authorizationEndpoint property. +func (o *OAuth20AuthCodeDetails) AuthorizationEndpointQualifiedName() string { + return o.authorizationEndpoint.QualifiedName() +} + +// SetAuthorizationEndpointQualifiedName sets the value of the authorizationEndpoint property. +func (o *OAuth20AuthCodeDetails) SetAuthorizationEndpointQualifiedName(v string) { + o.authorizationEndpoint.SetQualifiedName(v) +} + +// CallbackUrlQualifiedName returns the value of the callbackUrl property. +func (o *OAuth20AuthCodeDetails) CallbackUrlQualifiedName() string { + return o.callbackUrl.QualifiedName() +} + +// SetCallbackUrlQualifiedName sets the value of the callbackUrl property. +func (o *OAuth20AuthCodeDetails) SetCallbackUrlQualifiedName(v string) { + o.callbackUrl.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OAuth20AuthCodeDetails) InitFromRaw(raw bson.Raw) { + o.providerName.Init(raw) + o.wellKnownEndPoint.Init(raw) + if val, err := raw.LookupErr("TenantId"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.tenantId.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ClientId"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.clientId.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ClientSecret"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.clientSecret.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("TokenEndPoint"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.tokenEndPoint.SetFromDecode(s) + } + } + o.scopes.Init(raw) + if val, err := raw.LookupErr("GrantType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.grantType.SetFromDecode(s) + } + } + o.audience.Init(raw) + o.responseType.Init(raw) + o.responseMode.Init(raw) + if val, err := raw.LookupErr("AuthorizationEndpoint"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.authorizationEndpoint.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("CallbackUrl"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.callbackUrl.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// OAuth20ClientCredentialsDetails +// ──────────────────────────────────────────────────────── + +type OAuth20ClientCredentialsDetails struct { + element.Base + providerName *property.Primitive[string] + wellKnownEndPoint *property.Primitive[string] + tenantId *property.ByNameRef[element.Element] + clientId *property.ByNameRef[element.Element] + clientSecret *property.ByNameRef[element.Element] + tokenEndPoint *property.ByNameRef[element.Element] + scopes *property.Primitive[string] + grantType *property.Enum[string] + audience *property.Primitive[string] +} + +// ProviderName returns the value of the providerName property. +func (o *OAuth20ClientCredentialsDetails) ProviderName() string { + return o.providerName.Get() +} + +// SetProviderName sets the value of the providerName property. +func (o *OAuth20ClientCredentialsDetails) SetProviderName(v string) { + o.providerName.Set(v) +} + +// WellKnownEndPoint returns the value of the wellKnownEndPoint property. +func (o *OAuth20ClientCredentialsDetails) WellKnownEndPoint() string { + return o.wellKnownEndPoint.Get() +} + +// SetWellKnownEndPoint sets the value of the wellKnownEndPoint property. +func (o *OAuth20ClientCredentialsDetails) SetWellKnownEndPoint(v string) { + o.wellKnownEndPoint.Set(v) +} + +// TenantIdQualifiedName returns the value of the tenantId property. +func (o *OAuth20ClientCredentialsDetails) TenantIdQualifiedName() string { + return o.tenantId.QualifiedName() +} + +// SetTenantIdQualifiedName sets the value of the tenantId property. +func (o *OAuth20ClientCredentialsDetails) SetTenantIdQualifiedName(v string) { + o.tenantId.SetQualifiedName(v) +} + +// ClientIdQualifiedName returns the value of the clientId property. +func (o *OAuth20ClientCredentialsDetails) ClientIdQualifiedName() string { + return o.clientId.QualifiedName() +} + +// SetClientIdQualifiedName sets the value of the clientId property. +func (o *OAuth20ClientCredentialsDetails) SetClientIdQualifiedName(v string) { + o.clientId.SetQualifiedName(v) +} + +// ClientSecretQualifiedName returns the value of the clientSecret property. +func (o *OAuth20ClientCredentialsDetails) ClientSecretQualifiedName() string { + return o.clientSecret.QualifiedName() +} + +// SetClientSecretQualifiedName sets the value of the clientSecret property. +func (o *OAuth20ClientCredentialsDetails) SetClientSecretQualifiedName(v string) { + o.clientSecret.SetQualifiedName(v) +} + +// TokenEndPointQualifiedName returns the value of the tokenEndPoint property. +func (o *OAuth20ClientCredentialsDetails) TokenEndPointQualifiedName() string { + return o.tokenEndPoint.QualifiedName() +} + +// SetTokenEndPointQualifiedName sets the value of the tokenEndPoint property. +func (o *OAuth20ClientCredentialsDetails) SetTokenEndPointQualifiedName(v string) { + o.tokenEndPoint.SetQualifiedName(v) +} + +// Scopes returns the value of the scopes property. +func (o *OAuth20ClientCredentialsDetails) Scopes() string { + return o.scopes.Get() +} + +// GrantType returns the value of the grantType property. +func (o *OAuth20ClientCredentialsDetails) GrantType() string { + return o.grantType.Get() +} + +// SetGrantType sets the value of the grantType property. +func (o *OAuth20ClientCredentialsDetails) SetGrantType(v string) { + o.grantType.Set(v) +} + +// Audience returns the value of the audience property. +func (o *OAuth20ClientCredentialsDetails) Audience() string { + return o.audience.Get() +} + +// SetAudience sets the value of the audience property. +func (o *OAuth20ClientCredentialsDetails) SetAudience(v string) { + o.audience.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OAuth20ClientCredentialsDetails) InitFromRaw(raw bson.Raw) { + o.providerName.Init(raw) + o.wellKnownEndPoint.Init(raw) + if val, err := raw.LookupErr("TenantId"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.tenantId.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ClientId"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.clientId.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ClientSecret"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.clientSecret.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("TokenEndPoint"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.tokenEndPoint.SetFromDecode(s) + } + } + o.scopes.Init(raw) + if val, err := raw.LookupErr("GrantType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.grantType.SetFromDecode(s) + } + } + o.audience.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initAuthentication creates a Authentication with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAuthentication() *Authentication { + o := &Authentication{} + o.SetTypeName("Authentication$Authentication") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.authenticationDetails = property.NewPart[element.Element]("AuthenticationDetails") + o.authenticationDetails.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.authenticationDetails}) + return o +} + +// NewAuthentication creates a new Authentication for user code. Marked dirty (bit 63 = new element). +func NewAuthentication() *Authentication { + o := initAuthentication() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBasicAuthenticationDetails creates a BasicAuthenticationDetails with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicAuthenticationDetails() *BasicAuthenticationDetails { + o := &BasicAuthenticationDetails{} + o.SetTypeName("Authentication$BasicAuthenticationDetails") + o.username = property.NewByNameRef[element.Element]("Username", "Constants$Constant") + o.username.Bind(&o.Base, 0) + o.password = property.NewByNameRef[element.Element]("Password", "Constants$Constant") + o.password.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.username, o.password}) + return o +} + +// NewBasicAuthenticationDetails creates a new BasicAuthenticationDetails for user code. Marked dirty (bit 63 = new element). +func NewBasicAuthenticationDetails() *BasicAuthenticationDetails { + o := initBasicAuthenticationDetails() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOAuth20AuthCodeDetails creates a OAuth20AuthCodeDetails with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOAuth20AuthCodeDetails() *OAuth20AuthCodeDetails { + o := &OAuth20AuthCodeDetails{} + o.SetTypeName("Authentication$OAuth20AuthCodeDetails") + o.providerName = property.NewPrimitive[string]("ProviderName", property.DecodeString) + o.providerName.Bind(&o.Base, 0) + o.wellKnownEndPoint = property.NewPrimitive[string]("WellKnownEndPoint", property.DecodeString) + o.wellKnownEndPoint.Bind(&o.Base, 1) + o.tenantId = property.NewByNameRef[element.Element]("TenantId", "Constants$Constant") + o.tenantId.Bind(&o.Base, 2) + o.clientId = property.NewByNameRef[element.Element]("ClientId", "Constants$Constant") + o.clientId.Bind(&o.Base, 3) + o.clientSecret = property.NewByNameRef[element.Element]("ClientSecret", "Constants$Constant") + o.clientSecret.Bind(&o.Base, 4) + o.tokenEndPoint = property.NewByNameRef[element.Element]("TokenEndPoint", "Constants$Constant") + o.tokenEndPoint.Bind(&o.Base, 5) + o.scopes = property.NewPrimitive[string]("Scopes", property.DecodeString) + o.scopes.Bind(&o.Base, 6) + o.grantType = property.NewEnum[string]("GrantType") + o.grantType.Bind(&o.Base, 7) + o.audience = property.NewPrimitive[string]("Audience", property.DecodeString) + o.audience.Bind(&o.Base, 8) + o.responseType = property.NewPrimitive[string]("ResponseType", property.DecodeString) + o.responseType.Bind(&o.Base, 9) + o.responseMode = property.NewPrimitive[string]("ResponseMode", property.DecodeString) + o.responseMode.Bind(&o.Base, 10) + o.authorizationEndpoint = property.NewByNameRef[element.Element]("AuthorizationEndpoint", "Constants$Constant") + o.authorizationEndpoint.Bind(&o.Base, 11) + o.callbackUrl = property.NewByNameRef[element.Element]("CallbackUrl", "Constants$Constant") + o.callbackUrl.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.providerName, o.wellKnownEndPoint, o.tenantId, o.clientId, o.clientSecret, o.tokenEndPoint, o.scopes, o.grantType, o.audience, o.responseType, o.responseMode, o.authorizationEndpoint, o.callbackUrl}) + return o +} + +// NewOAuth20AuthCodeDetails creates a new OAuth20AuthCodeDetails for user code. Marked dirty (bit 63 = new element). +func NewOAuth20AuthCodeDetails() *OAuth20AuthCodeDetails { + o := initOAuth20AuthCodeDetails() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOAuth20ClientCredentialsDetails creates a OAuth20ClientCredentialsDetails with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOAuth20ClientCredentialsDetails() *OAuth20ClientCredentialsDetails { + o := &OAuth20ClientCredentialsDetails{} + o.SetTypeName("Authentication$OAuth20ClientCredentialsDetails") + o.providerName = property.NewPrimitive[string]("ProviderName", property.DecodeString) + o.providerName.Bind(&o.Base, 0) + o.wellKnownEndPoint = property.NewPrimitive[string]("WellKnownEndPoint", property.DecodeString) + o.wellKnownEndPoint.Bind(&o.Base, 1) + o.tenantId = property.NewByNameRef[element.Element]("TenantId", "Constants$Constant") + o.tenantId.Bind(&o.Base, 2) + o.clientId = property.NewByNameRef[element.Element]("ClientId", "Constants$Constant") + o.clientId.Bind(&o.Base, 3) + o.clientSecret = property.NewByNameRef[element.Element]("ClientSecret", "Constants$Constant") + o.clientSecret.Bind(&o.Base, 4) + o.tokenEndPoint = property.NewByNameRef[element.Element]("TokenEndPoint", "Constants$Constant") + o.tokenEndPoint.Bind(&o.Base, 5) + o.scopes = property.NewPrimitive[string]("Scopes", property.DecodeString) + o.scopes.Bind(&o.Base, 6) + o.grantType = property.NewEnum[string]("GrantType") + o.grantType.Bind(&o.Base, 7) + o.audience = property.NewPrimitive[string]("Audience", property.DecodeString) + o.audience.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.providerName, o.wellKnownEndPoint, o.tenantId, o.clientId, o.clientSecret, o.tokenEndPoint, o.scopes, o.grantType, o.audience}) + return o +} + +// NewOAuth20ClientCredentialsDetails creates a new OAuth20ClientCredentialsDetails for user code. Marked dirty (bit 63 = new element). +func NewOAuth20ClientCredentialsDetails() *OAuth20ClientCredentialsDetails { + o := initOAuth20ClientCredentialsDetails() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Authentication$Authentication", func() element.Element { + return initAuthentication() + }) + codec.DefaultRegistry.Register("Authentication$BasicAuthenticationDetails", func() element.Element { + return initBasicAuthenticationDetails() + }) + codec.DefaultRegistry.Register("Authentication$OAuth20AuthCodeDetails", func() element.Element { + return initOAuth20AuthCodeDetails() + }) + codec.DefaultRegistry.Register("Authentication$OAuth20ClientCredentialsDetails", func() element.Element { + return initOAuth20ClientCredentialsDetails() + }) +} diff --git a/modelsdk/gen/authentication/version.go b/modelsdk/gen/authentication/version.go new file mode 100644 index 00000000..f25177df --- /dev/null +++ b/modelsdk/gen/authentication/version.go @@ -0,0 +1,25 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package authentication + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Authentication$OAuth20AuthenticationDetails": { + Properties: map[string]version.PropertyVersionInfo{ + "audience": {Introduced: "11.5.0"}, + "clientId": {}, + "clientSecret": {}, + "tokenEndPoint": {}, + }, + }, + "Authentication$OAuth20AuthCodeDetails": { + Properties: map[string]version.PropertyVersionInfo{ + "authorizationEndpoint": {}, + "callbackUrl": {}, + }, + }, +} diff --git a/modelsdk/gen/businessevents/enums.go b/modelsdk/gen/businessevents/enums.go new file mode 100644 index 00000000..8f1bc6cc --- /dev/null +++ b/modelsdk/gen/businessevents/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package businessevents diff --git a/modelsdk/gen/businessevents/refs.go b/modelsdk/gen/businessevents/refs.go new file mode 100644 index 00000000..9ceed8c2 --- /dev/null +++ b/modelsdk/gen/businessevents/refs.go @@ -0,0 +1,24 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package businessevents + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("BusinessEvents$ConsumedBusinessEvent", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("BusinessEvents$PublishedMessage", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("BusinessEvents$PublishedMessageAttribute", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("BusinessEvents$ServiceOperation", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) +} diff --git a/modelsdk/gen/businessevents/types.go b/modelsdk/gen/businessevents/types.go new file mode 100644 index 00000000..a8fe47eb --- /dev/null +++ b/modelsdk/gen/businessevents/types.go @@ -0,0 +1,1554 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package businessevents + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// AttributeEnumeration +// ──────────────────────────────────────────────────────── + +type AttributeEnumeration struct { + element.Base + items *property.PartList[element.Element] +} + +// ItemsItems returns the value of the items property. +func (o *AttributeEnumeration) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *AttributeEnumeration) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *AttributeEnumeration) RemoveItems(index int) { + o.items.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AttributeEnumeration) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// AttributeEnumerationItem +// ──────────────────────────────────────────────────────── + +type AttributeEnumerationItem struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *AttributeEnumerationItem) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *AttributeEnumerationItem) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AttributeEnumerationItem) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// BusinessEventDefinition +// ──────────────────────────────────────────────────────── + +type BusinessEventDefinition struct { + element.Base + serviceName *property.Primitive[string] + eventNamePrefix *property.Primitive[string] + description *property.Primitive[string] + summary *property.Primitive[string] + channels *property.PartList[element.Element] +} + +// ServiceName returns the value of the serviceName property. +func (o *BusinessEventDefinition) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *BusinessEventDefinition) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// EventNamePrefix returns the value of the eventNamePrefix property. +func (o *BusinessEventDefinition) EventNamePrefix() string { + return o.eventNamePrefix.Get() +} + +// SetEventNamePrefix sets the value of the eventNamePrefix property. +func (o *BusinessEventDefinition) SetEventNamePrefix(v string) { + o.eventNamePrefix.Set(v) +} + +// Description returns the value of the description property. +func (o *BusinessEventDefinition) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *BusinessEventDefinition) SetDescription(v string) { + o.description.Set(v) +} + +// Summary returns the value of the summary property. +func (o *BusinessEventDefinition) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *BusinessEventDefinition) SetSummary(v string) { + o.summary.Set(v) +} + +// ChannelsItems returns the value of the channels property. +func (o *BusinessEventDefinition) ChannelsItems() []element.Element { + return o.channels.Items() +} + +// AddChannels appends a child element to the channels list. +func (o *BusinessEventDefinition) AddChannels(v element.Element) { + o.channels.Append(v) +} + +// RemoveChannels removes the element at the given index from the channels list. +func (o *BusinessEventDefinition) RemoveChannels(index int) { + o.channels.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BusinessEventDefinition) InitFromRaw(raw bson.Raw) { + o.serviceName.Init(raw) + o.eventNamePrefix.Init(raw) + o.description.Init(raw) + o.summary.Init(raw) + if children, err := codec.DecodeChildren(raw, "Channels"); err == nil { + for _, child := range children { + o.channels.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// BusinessEventService +// ──────────────────────────────────────────────────────── + +type BusinessEventService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + definition *property.Part[element.Element] + document *property.Primitive[string] + operationImplementations *property.PartList[element.Element] + sourceApi *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *BusinessEventService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *BusinessEventService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *BusinessEventService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *BusinessEventService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *BusinessEventService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *BusinessEventService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *BusinessEventService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *BusinessEventService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Definition returns the value of the definition property. +func (o *BusinessEventService) Definition() element.Element { + return o.definition.Get() +} + +// SetDefinition sets the value of the definition property. +func (o *BusinessEventService) SetDefinition(v element.Element) { + o.definition.Set(v) +} + +// Document returns the value of the document property. +func (o *BusinessEventService) Document() string { + return o.document.Get() +} + +// SetDocument sets the value of the document property. +func (o *BusinessEventService) SetDocument(v string) { + o.document.Set(v) +} + +// OperationImplementationsItems returns the value of the operationImplementations property. +func (o *BusinessEventService) OperationImplementationsItems() []element.Element { + return o.operationImplementations.Items() +} + +// AddOperationImplementations appends a child element to the operationImplementations list. +func (o *BusinessEventService) AddOperationImplementations(v element.Element) { + o.operationImplementations.Append(v) +} + +// RemoveOperationImplementations removes the element at the given index from the operationImplementations list. +func (o *BusinessEventService) RemoveOperationImplementations(index int) { + o.operationImplementations.Remove(index) +} + +// SourceApi returns the value of the sourceApi property. +func (o *BusinessEventService) SourceApi() element.Element { + return o.sourceApi.Get() +} + +// SetSourceApi sets the value of the sourceApi property. +func (o *BusinessEventService) SetSourceApi(v element.Element) { + o.sourceApi.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BusinessEventService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Definition"); err == nil { + o.definition.SetFromDecode(child) + } + o.document.Init(raw) + if children, err := codec.DecodeChildren(raw, "OperationImplementations"); err == nil { + for _, child := range children { + o.operationImplementations.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "SourceApi"); err == nil { + o.sourceApi.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Channel +// ──────────────────────────────────────────────────────── + +type Channel struct { + element.Base + channelName *property.Primitive[string] + description *property.Primitive[string] + messages *property.PartList[element.Element] +} + +// ChannelName returns the value of the channelName property. +func (o *Channel) ChannelName() string { + return o.channelName.Get() +} + +// SetChannelName sets the value of the channelName property. +func (o *Channel) SetChannelName(v string) { + o.channelName.Set(v) +} + +// Description returns the value of the description property. +func (o *Channel) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *Channel) SetDescription(v string) { + o.description.Set(v) +} + +// MessagesItems returns the value of the messages property. +func (o *Channel) MessagesItems() []element.Element { + return o.messages.Items() +} + +// AddMessages appends a child element to the messages list. +func (o *Channel) AddMessages(v element.Element) { + o.messages.Append(v) +} + +// RemoveMessages removes the element at the given index from the messages list. +func (o *Channel) RemoveMessages(index int) { + o.messages.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Channel) InitFromRaw(raw bson.Raw) { + o.channelName.Init(raw) + o.description.Init(raw) + if children, err := codec.DecodeChildren(raw, "Messages"); err == nil { + for _, child := range children { + o.messages.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ConsumedBusinessEvent +// ──────────────────────────────────────────────────────── + +type ConsumedBusinessEvent struct { + element.Base + eventName *property.Primitive[string] + channelId *property.Primitive[string] + entity *property.ByNameRef[element.Element] + microflow *property.ByNameRef[element.Element] +} + +// EventName returns the value of the eventName property. +func (o *ConsumedBusinessEvent) EventName() string { + return o.eventName.Get() +} + +// SetEventName sets the value of the eventName property. +func (o *ConsumedBusinessEvent) SetEventName(v string) { + o.eventName.Set(v) +} + +// ChannelId returns the value of the channelId property. +func (o *ConsumedBusinessEvent) ChannelId() string { + return o.channelId.Get() +} + +// SetChannelId sets the value of the channelId property. +func (o *ConsumedBusinessEvent) SetChannelId(v string) { + o.channelId.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ConsumedBusinessEvent) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ConsumedBusinessEvent) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *ConsumedBusinessEvent) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *ConsumedBusinessEvent) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConsumedBusinessEvent) InitFromRaw(raw bson.Raw) { + o.eventName.Init(raw) + o.channelId.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ConsumedBusinessEventService +// ──────────────────────────────────────────────────────── + +type ConsumedBusinessEventService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + version *property.Primitive[string] + contract *property.Primitive[string] + businessEvents *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *ConsumedBusinessEventService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConsumedBusinessEventService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ConsumedBusinessEventService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ConsumedBusinessEventService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ConsumedBusinessEventService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ConsumedBusinessEventService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ConsumedBusinessEventService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ConsumedBusinessEventService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Version returns the value of the version property. +func (o *ConsumedBusinessEventService) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *ConsumedBusinessEventService) SetVersion(v string) { + o.version.Set(v) +} + +// Contract returns the value of the contract property. +func (o *ConsumedBusinessEventService) Contract() string { + return o.contract.Get() +} + +// SetContract sets the value of the contract property. +func (o *ConsumedBusinessEventService) SetContract(v string) { + o.contract.Set(v) +} + +// BusinessEventsItems returns the value of the businessEvents property. +func (o *ConsumedBusinessEventService) BusinessEventsItems() []element.Element { + return o.businessEvents.Items() +} + +// AddBusinessEvents appends a child element to the businessEvents list. +func (o *ConsumedBusinessEventService) AddBusinessEvents(v element.Element) { + o.businessEvents.Append(v) +} + +// RemoveBusinessEvents removes the element at the given index from the businessEvents list. +func (o *ConsumedBusinessEventService) RemoveBusinessEvents(index int) { + o.businessEvents.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConsumedBusinessEventService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.version.Init(raw) + o.contract.Init(raw) + if children, err := codec.DecodeChildren(raw, "BusinessEvents"); err == nil { + for _, child := range children { + o.businessEvents.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Message +// ──────────────────────────────────────────────────────── + +type Message struct { + element.Base + messageName *property.Primitive[string] + description *property.Primitive[string] + attributes *property.PartList[element.Element] + canPublish *property.Primitive[bool] + canSubscribe *property.Primitive[bool] +} + +// MessageName returns the value of the messageName property. +func (o *Message) MessageName() string { + return o.messageName.Get() +} + +// SetMessageName sets the value of the messageName property. +func (o *Message) SetMessageName(v string) { + o.messageName.Set(v) +} + +// Description returns the value of the description property. +func (o *Message) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *Message) SetDescription(v string) { + o.description.Set(v) +} + +// AttributesItems returns the value of the attributes property. +func (o *Message) AttributesItems() []element.Element { + return o.attributes.Items() +} + +// AddAttributes appends a child element to the attributes list. +func (o *Message) AddAttributes(v element.Element) { + o.attributes.Append(v) +} + +// RemoveAttributes removes the element at the given index from the attributes list. +func (o *Message) RemoveAttributes(index int) { + o.attributes.Remove(index) +} + +// CanPublish returns the value of the canPublish property. +func (o *Message) CanPublish() bool { + return o.canPublish.Get() +} + +// SetCanPublish sets the value of the canPublish property. +func (o *Message) SetCanPublish(v bool) { + o.canPublish.Set(v) +} + +// CanSubscribe returns the value of the canSubscribe property. +func (o *Message) CanSubscribe() bool { + return o.canSubscribe.Get() +} + +// SetCanSubscribe sets the value of the canSubscribe property. +func (o *Message) SetCanSubscribe(v bool) { + o.canSubscribe.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Message) InitFromRaw(raw bson.Raw) { + o.messageName.Init(raw) + o.description.Init(raw) + if children, err := codec.DecodeChildren(raw, "Attributes"); err == nil { + for _, child := range children { + o.attributes.AppendFromDecode(child) + } + } + o.canPublish.Init(raw) + o.canSubscribe.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MessageAttribute +// ──────────────────────────────────────────────────────── + +type MessageAttribute struct { + element.Base + attributeType *property.Part[element.Element] + attributeName *property.Primitive[string] + description *property.Primitive[string] + enumerationDefinition *property.Part[element.Element] +} + +// AttributeType returns the value of the attributeType property. +func (o *MessageAttribute) AttributeType() element.Element { + return o.attributeType.Get() +} + +// SetAttributeType sets the value of the attributeType property. +func (o *MessageAttribute) SetAttributeType(v element.Element) { + o.attributeType.Set(v) +} + +// AttributeName returns the value of the attributeName property. +func (o *MessageAttribute) AttributeName() string { + return o.attributeName.Get() +} + +// SetAttributeName sets the value of the attributeName property. +func (o *MessageAttribute) SetAttributeName(v string) { + o.attributeName.Set(v) +} + +// Description returns the value of the description property. +func (o *MessageAttribute) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *MessageAttribute) SetDescription(v string) { + o.description.Set(v) +} + +// EnumerationDefinition returns the value of the enumerationDefinition property. +func (o *MessageAttribute) EnumerationDefinition() element.Element { + return o.enumerationDefinition.Get() +} + +// SetEnumerationDefinition sets the value of the enumerationDefinition property. +func (o *MessageAttribute) SetEnumerationDefinition(v element.Element) { + o.enumerationDefinition.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MessageAttribute) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "AttributeType"); err == nil { + o.attributeType.SetFromDecode(child) + } + o.attributeName.Init(raw) + o.description.Init(raw) + if child, err := codec.DecodeChild(raw, "EnumerationDefinition"); err == nil { + o.enumerationDefinition.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// PublishedBusinessEventService +// ──────────────────────────────────────────────────────── + +type PublishedBusinessEventService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + serviceName *property.Primitive[string] + eventNamePrefix *property.Primitive[string] + version *property.Primitive[string] + description *property.Primitive[string] + summary *property.Primitive[string] + channels *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *PublishedBusinessEventService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedBusinessEventService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedBusinessEventService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedBusinessEventService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *PublishedBusinessEventService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *PublishedBusinessEventService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *PublishedBusinessEventService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *PublishedBusinessEventService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *PublishedBusinessEventService) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *PublishedBusinessEventService) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// EventNamePrefix returns the value of the eventNamePrefix property. +func (o *PublishedBusinessEventService) EventNamePrefix() string { + return o.eventNamePrefix.Get() +} + +// SetEventNamePrefix sets the value of the eventNamePrefix property. +func (o *PublishedBusinessEventService) SetEventNamePrefix(v string) { + o.eventNamePrefix.Set(v) +} + +// Version returns the value of the version property. +func (o *PublishedBusinessEventService) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *PublishedBusinessEventService) SetVersion(v string) { + o.version.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedBusinessEventService) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedBusinessEventService) SetDescription(v string) { + o.description.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedBusinessEventService) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedBusinessEventService) SetSummary(v string) { + o.summary.Set(v) +} + +// ChannelsItems returns the value of the channels property. +func (o *PublishedBusinessEventService) ChannelsItems() []element.Element { + return o.channels.Items() +} + +// AddChannels appends a child element to the channels list. +func (o *PublishedBusinessEventService) AddChannels(v element.Element) { + o.channels.Append(v) +} + +// RemoveChannels removes the element at the given index from the channels list. +func (o *PublishedBusinessEventService) RemoveChannels(index int) { + o.channels.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedBusinessEventService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.serviceName.Init(raw) + o.eventNamePrefix.Init(raw) + o.version.Init(raw) + o.description.Init(raw) + o.summary.Init(raw) + if children, err := codec.DecodeChildren(raw, "Channels"); err == nil { + for _, child := range children { + o.channels.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// PublishedChannel +// ──────────────────────────────────────────────────────── + +type PublishedChannel struct { + element.Base + channelId *property.Primitive[string] + channelName *property.Primitive[string] + description *property.Primitive[string] + messages *property.PartList[element.Element] +} + +// ChannelId returns the value of the channelId property. +func (o *PublishedChannel) ChannelId() string { + return o.channelId.Get() +} + +// SetChannelId sets the value of the channelId property. +func (o *PublishedChannel) SetChannelId(v string) { + o.channelId.Set(v) +} + +// ChannelName returns the value of the channelName property. +func (o *PublishedChannel) ChannelName() string { + return o.channelName.Get() +} + +// SetChannelName sets the value of the channelName property. +func (o *PublishedChannel) SetChannelName(v string) { + o.channelName.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedChannel) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedChannel) SetDescription(v string) { + o.description.Set(v) +} + +// MessagesItems returns the value of the messages property. +func (o *PublishedChannel) MessagesItems() []element.Element { + return o.messages.Items() +} + +// AddMessages appends a child element to the messages list. +func (o *PublishedChannel) AddMessages(v element.Element) { + o.messages.Append(v) +} + +// RemoveMessages removes the element at the given index from the messages list. +func (o *PublishedChannel) RemoveMessages(index int) { + o.messages.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedChannel) InitFromRaw(raw bson.Raw) { + o.channelId.Init(raw) + o.channelName.Init(raw) + o.description.Init(raw) + if children, err := codec.DecodeChildren(raw, "Messages"); err == nil { + for _, child := range children { + o.messages.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// PublishedMessage +// ──────────────────────────────────────────────────────── + +type PublishedMessage struct { + element.Base + entity *property.ByNameRef[element.Element] + exposedName *property.Primitive[string] + eventName *property.Primitive[string] + description *property.Primitive[string] + summary *property.Primitive[string] + attributes *property.PartList[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *PublishedMessage) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *PublishedMessage) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedMessage) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedMessage) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// EventName returns the value of the eventName property. +func (o *PublishedMessage) EventName() string { + return o.eventName.Get() +} + +// SetEventName sets the value of the eventName property. +func (o *PublishedMessage) SetEventName(v string) { + o.eventName.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedMessage) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedMessage) SetDescription(v string) { + o.description.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedMessage) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedMessage) SetSummary(v string) { + o.summary.Set(v) +} + +// AttributesItems returns the value of the attributes property. +func (o *PublishedMessage) AttributesItems() []element.Element { + return o.attributes.Items() +} + +// AddAttributes appends a child element to the attributes list. +func (o *PublishedMessage) AddAttributes(v element.Element) { + o.attributes.Append(v) +} + +// RemoveAttributes removes the element at the given index from the attributes list. +func (o *PublishedMessage) RemoveAttributes(index int) { + o.attributes.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedMessage) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + o.exposedName.Init(raw) + o.eventName.Init(raw) + o.description.Init(raw) + o.summary.Init(raw) + if children, err := codec.DecodeChildren(raw, "Attributes"); err == nil { + for _, child := range children { + o.attributes.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// PublishedMessageAttribute +// ──────────────────────────────────────────────────────── + +type PublishedMessageAttribute struct { + element.Base + attribute *property.ByNameRef[element.Element] + attributeType *property.Part[element.Element] + exposedName *property.Primitive[string] + description *property.Primitive[string] +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *PublishedMessageAttribute) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *PublishedMessageAttribute) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// AttributeType returns the value of the attributeType property. +func (o *PublishedMessageAttribute) AttributeType() element.Element { + return o.attributeType.Get() +} + +// SetAttributeType sets the value of the attributeType property. +func (o *PublishedMessageAttribute) SetAttributeType(v element.Element) { + o.attributeType.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedMessageAttribute) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedMessageAttribute) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedMessageAttribute) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedMessageAttribute) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedMessageAttribute) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "AttributeType"); err == nil { + o.attributeType.SetFromDecode(child) + } + o.exposedName.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ServiceOperation +// ──────────────────────────────────────────────────────── + +type ServiceOperation struct { + element.Base + messageName *property.Primitive[string] + operation *property.Primitive[string] + entity *property.ByNameRef[element.Element] + microflow *property.ByNameRef[element.Element] +} + +// MessageName returns the value of the messageName property. +func (o *ServiceOperation) MessageName() string { + return o.messageName.Get() +} + +// SetMessageName sets the value of the messageName property. +func (o *ServiceOperation) SetMessageName(v string) { + o.messageName.Set(v) +} + +// Operation returns the value of the operation property. +func (o *ServiceOperation) Operation() string { + return o.operation.Get() +} + +// SetOperation sets the value of the operation property. +func (o *ServiceOperation) SetOperation(v string) { + o.operation.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ServiceOperation) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ServiceOperation) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *ServiceOperation) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *ServiceOperation) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ServiceOperation) InitFromRaw(raw bson.Raw) { + o.messageName.Init(raw) + o.operation.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initAttributeEnumeration creates a AttributeEnumeration with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAttributeEnumeration() *AttributeEnumeration { + o := &AttributeEnumeration{} + o.SetTypeName("BusinessEvents$AttributeEnumeration") + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.items}) + return o +} + +// NewAttributeEnumeration creates a new AttributeEnumeration for user code. Marked dirty (bit 63 = new element). +func NewAttributeEnumeration() *AttributeEnumeration { + o := initAttributeEnumeration() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAttributeEnumerationItem creates a AttributeEnumerationItem with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAttributeEnumerationItem() *AttributeEnumerationItem { + o := &AttributeEnumerationItem{} + o.SetTypeName("BusinessEvents$AttributeEnumerationItem") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value}) + return o +} + +// NewAttributeEnumerationItem creates a new AttributeEnumerationItem for user code. Marked dirty (bit 63 = new element). +func NewAttributeEnumerationItem() *AttributeEnumerationItem { + o := initAttributeEnumerationItem() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBusinessEventDefinition creates a BusinessEventDefinition with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBusinessEventDefinition() *BusinessEventDefinition { + o := &BusinessEventDefinition{} + o.SetTypeName("BusinessEvents$BusinessEventDefinition") + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 0) + o.eventNamePrefix = property.NewPrimitive[string]("EventNamePrefix", property.DecodeString) + o.eventNamePrefix.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 3) + o.channels = property.NewPartList[element.Element]("Channels") + o.channels.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.serviceName, o.eventNamePrefix, o.description, o.summary, o.channels}) + return o +} + +// NewBusinessEventDefinition creates a new BusinessEventDefinition for user code. Marked dirty (bit 63 = new element). +func NewBusinessEventDefinition() *BusinessEventDefinition { + o := initBusinessEventDefinition() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBusinessEventService creates a BusinessEventService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBusinessEventService() *BusinessEventService { + o := &BusinessEventService{} + o.SetTypeName("BusinessEvents$BusinessEventService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.definition = property.NewPart[element.Element]("Definition") + o.definition.Bind(&o.Base, 4) + o.document = property.NewPrimitive[string]("Document", property.DecodeString) + o.document.Bind(&o.Base, 5) + o.operationImplementations = property.NewPartList[element.Element]("OperationImplementations") + o.operationImplementations.Bind(&o.Base, 6) + o.sourceApi = property.NewPart[element.Element]("SourceApi") + o.sourceApi.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.definition, o.document, o.operationImplementations, o.sourceApi}) + return o +} + +// NewBusinessEventService creates a new BusinessEventService for user code. Marked dirty (bit 63 = new element). +func NewBusinessEventService() *BusinessEventService { + o := initBusinessEventService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initChannel creates a Channel with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initChannel() *Channel { + o := &Channel{} + o.SetTypeName("BusinessEvents$Channel") + o.channelName = property.NewPrimitive[string]("ChannelName", property.DecodeString) + o.channelName.Bind(&o.Base, 0) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 1) + o.messages = property.NewPartList[element.Element]("Messages") + o.messages.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.channelName, o.description, o.messages}) + return o +} + +// NewChannel creates a new Channel for user code. Marked dirty (bit 63 = new element). +func NewChannel() *Channel { + o := initChannel() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConsumedBusinessEvent creates a ConsumedBusinessEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConsumedBusinessEvent() *ConsumedBusinessEvent { + o := &ConsumedBusinessEvent{} + o.SetTypeName("BusinessEvents$ConsumedBusinessEvent") + o.eventName = property.NewPrimitive[string]("EventName", property.DecodeString) + o.eventName.Bind(&o.Base, 0) + o.channelId = property.NewPrimitive[string]("ChannelId", property.DecodeString) + o.channelId.Bind(&o.Base, 1) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 2) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.eventName, o.channelId, o.entity, o.microflow}) + return o +} + +// NewConsumedBusinessEvent creates a new ConsumedBusinessEvent for user code. Marked dirty (bit 63 = new element). +func NewConsumedBusinessEvent() *ConsumedBusinessEvent { + o := initConsumedBusinessEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConsumedBusinessEventService creates a ConsumedBusinessEventService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConsumedBusinessEventService() *ConsumedBusinessEventService { + o := &ConsumedBusinessEventService{} + o.SetTypeName("BusinessEvents$ConsumedBusinessEventService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 4) + o.contract = property.NewPrimitive[string]("Contract", property.DecodeString) + o.contract.Bind(&o.Base, 5) + o.businessEvents = property.NewPartList[element.Element]("BusinessEvents") + o.businessEvents.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.version, o.contract, o.businessEvents}) + return o +} + +// NewConsumedBusinessEventService creates a new ConsumedBusinessEventService for user code. Marked dirty (bit 63 = new element). +func NewConsumedBusinessEventService() *ConsumedBusinessEventService { + o := initConsumedBusinessEventService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMessage creates a Message with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMessage() *Message { + o := &Message{} + o.SetTypeName("BusinessEvents$Message") + o.messageName = property.NewPrimitive[string]("MessageName", property.DecodeString) + o.messageName.Bind(&o.Base, 0) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 1) + o.attributes = property.NewPartList[element.Element]("Attributes") + o.attributes.Bind(&o.Base, 2) + o.canPublish = property.NewPrimitive[bool]("CanPublish", property.DecodeBool) + o.canPublish.Bind(&o.Base, 3) + o.canSubscribe = property.NewPrimitive[bool]("CanSubscribe", property.DecodeBool) + o.canSubscribe.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.messageName, o.description, o.attributes, o.canPublish, o.canSubscribe}) + return o +} + +// NewMessage creates a new Message for user code. Marked dirty (bit 63 = new element). +func NewMessage() *Message { + o := initMessage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMessageAttribute creates a MessageAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMessageAttribute() *MessageAttribute { + o := &MessageAttribute{} + o.SetTypeName("BusinessEvents$MessageAttribute") + o.attributeType = property.NewPart[element.Element]("AttributeType") + o.attributeType.Bind(&o.Base, 0) + o.attributeName = property.NewPrimitive[string]("AttributeName", property.DecodeString) + o.attributeName.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.enumerationDefinition = property.NewPart[element.Element]("EnumerationDefinition") + o.enumerationDefinition.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.attributeType, o.attributeName, o.description, o.enumerationDefinition}) + return o +} + +// NewMessageAttribute creates a new MessageAttribute for user code. Marked dirty (bit 63 = new element). +func NewMessageAttribute() *MessageAttribute { + o := initMessageAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedBusinessEventService creates a PublishedBusinessEventService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedBusinessEventService() *PublishedBusinessEventService { + o := &PublishedBusinessEventService{} + o.SetTypeName("BusinessEvents$PublishedBusinessEventService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 4) + o.eventNamePrefix = property.NewPrimitive[string]("EventNamePrefix", property.DecodeString) + o.eventNamePrefix.Bind(&o.Base, 5) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 6) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 7) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 8) + o.channels = property.NewPartList[element.Element]("Channels") + o.channels.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.serviceName, o.eventNamePrefix, o.version, o.description, o.summary, o.channels}) + return o +} + +// NewPublishedBusinessEventService creates a new PublishedBusinessEventService for user code. Marked dirty (bit 63 = new element). +func NewPublishedBusinessEventService() *PublishedBusinessEventService { + o := initPublishedBusinessEventService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedChannel creates a PublishedChannel with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedChannel() *PublishedChannel { + o := &PublishedChannel{} + o.SetTypeName("BusinessEvents$PublishedChannel") + o.channelId = property.NewPrimitive[string]("ChannelId", property.DecodeString) + o.channelId.Bind(&o.Base, 0) + o.channelName = property.NewPrimitive[string]("ChannelName", property.DecodeString) + o.channelName.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.messages = property.NewPartList[element.Element]("Messages") + o.messages.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.channelId, o.channelName, o.description, o.messages}) + return o +} + +// NewPublishedChannel creates a new PublishedChannel for user code. Marked dirty (bit 63 = new element). +func NewPublishedChannel() *PublishedChannel { + o := initPublishedChannel() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedMessage creates a PublishedMessage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedMessage() *PublishedMessage { + o := &PublishedMessage{} + o.SetTypeName("BusinessEvents$PublishedMessage") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 1) + o.eventName = property.NewPrimitive[string]("EventName", property.DecodeString) + o.eventName.Bind(&o.Base, 2) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 3) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 4) + o.attributes = property.NewPartList[element.Element]("Attributes") + o.attributes.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.entity, o.exposedName, o.eventName, o.description, o.summary, o.attributes}) + return o +} + +// NewPublishedMessage creates a new PublishedMessage for user code. Marked dirty (bit 63 = new element). +func NewPublishedMessage() *PublishedMessage { + o := initPublishedMessage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedMessageAttribute creates a PublishedMessageAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedMessageAttribute() *PublishedMessageAttribute { + o := &PublishedMessageAttribute{} + o.SetTypeName("BusinessEvents$PublishedMessageAttribute") + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 0) + o.attributeType = property.NewPart[element.Element]("AttributeType") + o.attributeType.Bind(&o.Base, 1) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 2) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.attribute, o.attributeType, o.exposedName, o.description}) + return o +} + +// NewPublishedMessageAttribute creates a new PublishedMessageAttribute for user code. Marked dirty (bit 63 = new element). +func NewPublishedMessageAttribute() *PublishedMessageAttribute { + o := initPublishedMessageAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initServiceOperation creates a ServiceOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initServiceOperation() *ServiceOperation { + o := &ServiceOperation{} + o.SetTypeName("BusinessEvents$ServiceOperation") + o.messageName = property.NewPrimitive[string]("MessageName", property.DecodeString) + o.messageName.Bind(&o.Base, 0) + o.operation = property.NewPrimitive[string]("Operation", property.DecodeString) + o.operation.Bind(&o.Base, 1) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 2) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.messageName, o.operation, o.entity, o.microflow}) + return o +} + +// NewServiceOperation creates a new ServiceOperation for user code. Marked dirty (bit 63 = new element). +func NewServiceOperation() *ServiceOperation { + o := initServiceOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("BusinessEvents$AttributeEnumeration", func() element.Element { + return initAttributeEnumeration() + }) + codec.DefaultRegistry.Register("BusinessEvents$AttributeEnumerationItem", func() element.Element { + return initAttributeEnumerationItem() + }) + codec.DefaultRegistry.Register("BusinessEvents$BusinessEventDefinition", func() element.Element { + return initBusinessEventDefinition() + }) + codec.DefaultRegistry.Register("BusinessEvents$BusinessEventService", func() element.Element { + return initBusinessEventService() + }) + codec.DefaultRegistry.Register("BusinessEvents$Channel", func() element.Element { + return initChannel() + }) + codec.DefaultRegistry.Register("BusinessEvents$ConsumedBusinessEvent", func() element.Element { + return initConsumedBusinessEvent() + }) + codec.DefaultRegistry.Register("BusinessEvents$ConsumedBusinessEventService", func() element.Element { + return initConsumedBusinessEventService() + }) + codec.DefaultRegistry.Register("BusinessEvents$Message", func() element.Element { + return initMessage() + }) + codec.DefaultRegistry.Register("BusinessEvents$MessageAttribute", func() element.Element { + return initMessageAttribute() + }) + codec.DefaultRegistry.Register("BusinessEvents$PublishedBusinessEventService", func() element.Element { + return initPublishedBusinessEventService() + }) + codec.DefaultRegistry.Register("BusinessEvents$PublishedChannel", func() element.Element { + return initPublishedChannel() + }) + codec.DefaultRegistry.Register("BusinessEvents$PublishedMessage", func() element.Element { + return initPublishedMessage() + }) + codec.DefaultRegistry.Register("BusinessEvents$PublishedMessageAttribute", func() element.Element { + return initPublishedMessageAttribute() + }) + codec.DefaultRegistry.Register("BusinessEvents$ServiceOperation", func() element.Element { + return initServiceOperation() + }) +} diff --git a/modelsdk/gen/businessevents/version.go b/modelsdk/gen/businessevents/version.go new file mode 100644 index 00000000..492a3d97 --- /dev/null +++ b/modelsdk/gen/businessevents/version.go @@ -0,0 +1,59 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package businessevents + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "BusinessEvents$BusinessEventService": { + Properties: map[string]version.PropertyVersionInfo{ + "sourceApi": {Introduced: "10.21.0"}, + }, + }, + "BusinessEvents$ConsumedBusinessEvent": { + Properties: map[string]version.PropertyVersionInfo{ + "channelId": {Introduced: "9.13.0"}, + "entity": {Required: true}, + "microflow": {Required: true}, + }, + }, + "BusinessEvents$ConsumedBusinessEventService": { + Properties: map[string]version.PropertyVersionInfo{ + "businessEvents": {Introduced: "9.11.0"}, + "contract": {Introduced: "9.11.0"}, + "version": {Introduced: "9.11.0"}, + }, + }, + "BusinessEvents$MessageAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "attributeType": {Required: true}, + "enumerationDefinition": {Introduced: "10.0.0"}, + }, + }, + "BusinessEvents$PublishedBusinessEventService": { + Properties: map[string]version.PropertyVersionInfo{ + "eventNamePrefix": {Introduced: "9.13.0"}, + }, + }, + "BusinessEvents$PublishedMessage": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true}, + "eventName": {Introduced: "9.12.0"}, + "exposedName": {Deleted: "9.12.0"}, + }, + }, + "BusinessEvents$PublishedMessageAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Required: true}, + "attributeType": {Introduced: "9.14.0", Required: true}, + }, + }, + "BusinessEvents$ServiceOperation": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/changedatacapture/enums.go b/modelsdk/gen/changedatacapture/enums.go new file mode 100644 index 00000000..cdde97e8 --- /dev/null +++ b/modelsdk/gen/changedatacapture/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package changedatacapture diff --git a/modelsdk/gen/changedatacapture/refs.go b/modelsdk/gen/changedatacapture/refs.go new file mode 100644 index 00000000..f8c109c6 --- /dev/null +++ b/modelsdk/gen/changedatacapture/refs.go @@ -0,0 +1,19 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package changedatacapture + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("ChangeDataCapture$AssociationProperty", []codec.RefMeta{ + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ChangeDataCapture$AttributeProperty", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ChangeDataCapture$EntityChangeSource", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) +} diff --git a/modelsdk/gen/changedatacapture/types.go b/modelsdk/gen/changedatacapture/types.go new file mode 100644 index 00000000..59514abc --- /dev/null +++ b/modelsdk/gen/changedatacapture/types.go @@ -0,0 +1,403 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package changedatacapture + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// EntityChangeProperty +// ──────────────────────────────────────────────────────── + +type EntityChangeProperty struct { + element.Base + exposedName *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *EntityChangeProperty) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *EntityChangeProperty) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityChangeProperty) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// AssociationProperty +// ──────────────────────────────────────────────────────── + +type AssociationProperty struct { + element.Base + exposedName *property.Primitive[string] + association *property.ByNameRef[element.Element] +} + +// ExposedName returns the value of the exposedName property. +func (o *AssociationProperty) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *AssociationProperty) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *AssociationProperty) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *AssociationProperty) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AssociationProperty) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.association.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// AttributeProperty +// ──────────────────────────────────────────────────────── + +type AttributeProperty struct { + element.Base + exposedName *property.Primitive[string] + attribute *property.ByNameRef[element.Element] +} + +// ExposedName returns the value of the exposedName property. +func (o *AttributeProperty) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *AttributeProperty) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *AttributeProperty) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *AttributeProperty) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AttributeProperty) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// EntityChangeDataCaptureService +// ──────────────────────────────────────────────────────── + +type EntityChangeDataCaptureService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + sources *property.PartList[element.Element] + serviceName *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *EntityChangeDataCaptureService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *EntityChangeDataCaptureService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *EntityChangeDataCaptureService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *EntityChangeDataCaptureService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *EntityChangeDataCaptureService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *EntityChangeDataCaptureService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *EntityChangeDataCaptureService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *EntityChangeDataCaptureService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// SourcesItems returns the value of the sources property. +func (o *EntityChangeDataCaptureService) SourcesItems() []element.Element { + return o.sources.Items() +} + +// AddSources appends a child element to the sources list. +func (o *EntityChangeDataCaptureService) AddSources(v element.Element) { + o.sources.Append(v) +} + +// RemoveSources removes the element at the given index from the sources list. +func (o *EntityChangeDataCaptureService) RemoveSources(index int) { + o.sources.Remove(index) +} + +// ServiceName returns the value of the serviceName property. +func (o *EntityChangeDataCaptureService) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *EntityChangeDataCaptureService) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityChangeDataCaptureService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Sources"); err == nil { + for _, child := range children { + o.sources.AppendFromDecode(child) + } + } + o.serviceName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EntityChangeSource +// ──────────────────────────────────────────────────────── + +type EntityChangeSource struct { + element.Base + entity *property.ByNameRef[element.Element] + exposedName *property.Primitive[string] + properties *property.PartList[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *EntityChangeSource) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *EntityChangeSource) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *EntityChangeSource) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *EntityChangeSource) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// PropertiesItems returns the value of the properties property. +func (o *EntityChangeSource) PropertiesItems() []element.Element { + return o.properties.Items() +} + +// AddProperties appends a child element to the properties list. +func (o *EntityChangeSource) AddProperties(v element.Element) { + o.properties.Append(v) +} + +// RemoveProperties removes the element at the given index from the properties list. +func (o *EntityChangeSource) RemoveProperties(index int) { + o.properties.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityChangeSource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + o.exposedName.Init(raw) + if children, err := codec.DecodeChildren(raw, "Properties"); err == nil { + for _, child := range children { + o.properties.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initAssociationProperty creates a AssociationProperty with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAssociationProperty() *AssociationProperty { + o := &AssociationProperty{} + o.SetTypeName("ChangeDataCapture$AssociationProperty") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.exposedName, o.association}) + return o +} + +// NewAssociationProperty creates a new AssociationProperty for user code. Marked dirty (bit 63 = new element). +func NewAssociationProperty() *AssociationProperty { + o := initAssociationProperty() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAttributeProperty creates a AttributeProperty with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAttributeProperty() *AttributeProperty { + o := &AttributeProperty{} + o.SetTypeName("ChangeDataCapture$AttributeProperty") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.exposedName, o.attribute}) + return o +} + +// NewAttributeProperty creates a new AttributeProperty for user code. Marked dirty (bit 63 = new element). +func NewAttributeProperty() *AttributeProperty { + o := initAttributeProperty() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityChangeDataCaptureService creates a EntityChangeDataCaptureService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityChangeDataCaptureService() *EntityChangeDataCaptureService { + o := &EntityChangeDataCaptureService{} + o.SetTypeName("ChangeDataCapture$EntityChangeDataCaptureService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.sources = property.NewPartList[element.Element]("Sources") + o.sources.Bind(&o.Base, 4) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.sources, o.serviceName}) + return o +} + +// NewEntityChangeDataCaptureService creates a new EntityChangeDataCaptureService for user code. Marked dirty (bit 63 = new element). +func NewEntityChangeDataCaptureService() *EntityChangeDataCaptureService { + o := initEntityChangeDataCaptureService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityChangeSource creates a EntityChangeSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityChangeSource() *EntityChangeSource { + o := &EntityChangeSource{} + o.SetTypeName("ChangeDataCapture$EntityChangeSource") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 1) + o.properties = property.NewPartList[element.Element]("Properties") + o.properties.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.entity, o.exposedName, o.properties}) + return o +} + +// NewEntityChangeSource creates a new EntityChangeSource for user code. Marked dirty (bit 63 = new element). +func NewEntityChangeSource() *EntityChangeSource { + o := initEntityChangeSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("ChangeDataCapture$AssociationProperty", func() element.Element { + return initAssociationProperty() + }) + codec.DefaultRegistry.Register("ChangeDataCapture$AttributeProperty", func() element.Element { + return initAttributeProperty() + }) + codec.DefaultRegistry.Register("ChangeDataCapture$EntityChangeDataCaptureService", func() element.Element { + return initEntityChangeDataCaptureService() + }) + codec.DefaultRegistry.Register("ChangeDataCapture$EntityChangeSource", func() element.Element { + return initEntityChangeSource() + }) +} diff --git a/modelsdk/gen/changedatacapture/version.go b/modelsdk/gen/changedatacapture/version.go new file mode 100644 index 00000000..548c830c --- /dev/null +++ b/modelsdk/gen/changedatacapture/version.go @@ -0,0 +1,33 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package changedatacapture + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "ChangeDataCapture$AssociationProperty": { + Properties: map[string]version.PropertyVersionInfo{ + "association": {Required: true}, + }, + }, + "ChangeDataCapture$AttributeProperty": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Required: true}, + }, + }, + "ChangeDataCapture$EntityChangeDataCaptureService": { + Properties: map[string]version.PropertyVersionInfo{ + "serviceName": {Introduced: "11.8.0"}, + }, + }, + "ChangeDataCapture$EntityChangeSource": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true}, + "exposedName": {Introduced: "11.9.0"}, + "properties": {Introduced: "11.9.0"}, + }, + }, +} diff --git a/modelsdk/gen/client/enums.go b/modelsdk/gen/client/enums.go new file mode 100644 index 00000000..6c0c4028 --- /dev/null +++ b/modelsdk/gen/client/enums.go @@ -0,0 +1,14 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package client + +// SupportedPlatform enumerates the possible values for the SupportedPlatform type. +type SupportedPlatform = string + +const ( + SupportedPlatformAll SupportedPlatform = "All" + SupportedPlatformWeb SupportedPlatform = "Web" + SupportedPlatformNative SupportedPlatform = "Native" +) diff --git a/modelsdk/gen/client/refs.go b/modelsdk/gen/client/refs.go new file mode 100644 index 00000000..11f7ab0b --- /dev/null +++ b/modelsdk/gen/client/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package client diff --git a/modelsdk/gen/client/types.go b/modelsdk/gen/client/types.go new file mode 100644 index 00000000..24f201b5 --- /dev/null +++ b/modelsdk/gen/client/types.go @@ -0,0 +1,27 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package client + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +func init() { +} diff --git a/modelsdk/gen/client/version.go b/modelsdk/gen/client/version.go new file mode 100644 index 00000000..088c9102 --- /dev/null +++ b/modelsdk/gen/client/version.go @@ -0,0 +1,10 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package client + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{} diff --git a/modelsdk/gen/codeactions/enums.go b/modelsdk/gen/codeactions/enums.go new file mode 100644 index 00000000..f38c6d46 --- /dev/null +++ b/modelsdk/gen/codeactions/enums.go @@ -0,0 +1,13 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package codeactions + +// StringTemplateParameterGrammar enumerates the possible values for the StringTemplateParameterGrammar type. +type StringTemplateParameterGrammar = string + +const ( + StringTemplateParameterGrammarText StringTemplateParameterGrammar = "Text" + StringTemplateParameterGrammarSql StringTemplateParameterGrammar = "Sql" +) diff --git a/modelsdk/gen/codeactions/refs.go b/modelsdk/gen/codeactions/refs.go new file mode 100644 index 00000000..e249df1e --- /dev/null +++ b/modelsdk/gen/codeactions/refs.go @@ -0,0 +1,25 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package codeactions + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("CodeActions$ConcreteEntityType", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("CodeActions$EntityTypeParameterType", []codec.RefMeta{ + {Prop: "TypeParameterPointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("CodeActions$EnumerationType", []codec.RefMeta{ + {Prop: "Enumeration", Kind: codec.RefByName, Target: "Enumerations$Enumeration"}, + }) + codec.DefaultRefRegistry.RegisterRefs("CodeActions$MicroflowActionInfo", []codec.RefMeta{ + {Prop: "Icon", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("CodeActions$ParameterizedEntityType", []codec.RefMeta{ + {Prop: "TypeParameterPointer", Kind: codec.RefById, Target: ""}, + }) +} diff --git a/modelsdk/gen/codeactions/types.go b/modelsdk/gen/codeactions/types.go new file mode 100644 index 00000000..09f532c7 --- /dev/null +++ b/modelsdk/gen/codeactions/types.go @@ -0,0 +1,1143 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package codeactions + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// ParameterType +// ──────────────────────────────────────────────────────── + +type ParameterType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ParameterType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BasicParameterType +// ──────────────────────────────────────────────────────── + +type BasicParameterType struct { + element.Base + propType *property.Part[element.Element] +} + +// Type returns the value of the type property. +func (o *BasicParameterType) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *BasicParameterType) SetType(v element.Element) { + o.propType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicParameterType) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Type +// ──────────────────────────────────────────────────────── + +type Type struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Type) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// PrimitiveType +// ──────────────────────────────────────────────────────── + +type PrimitiveType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PrimitiveType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BooleanType +// ──────────────────────────────────────────────────────── + +type BooleanType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BooleanType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CodeAction +// ──────────────────────────────────────────────────────── + +type CodeAction struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + actionTypeParameters *property.PartList[element.Element] + actionReturnType *property.Part[element.Element] + actionDefaultReturnName *property.Primitive[string] + modelerActionInfo *property.Part[element.Element] + actionParameters *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *CodeAction) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CodeAction) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *CodeAction) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *CodeAction) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *CodeAction) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *CodeAction) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *CodeAction) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *CodeAction) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ActionTypeParametersItems returns the value of the actionTypeParameters property. +func (o *CodeAction) ActionTypeParametersItems() []element.Element { + return o.actionTypeParameters.Items() +} + +// AddActionTypeParameters appends a child element to the actionTypeParameters list. +func (o *CodeAction) AddActionTypeParameters(v element.Element) { + o.actionTypeParameters.Append(v) +} + +// RemoveActionTypeParameters removes the element at the given index from the actionTypeParameters list. +func (o *CodeAction) RemoveActionTypeParameters(index int) { + o.actionTypeParameters.Remove(index) +} + +// ActionReturnType returns the value of the actionReturnType property. +func (o *CodeAction) ActionReturnType() element.Element { + return o.actionReturnType.Get() +} + +// SetActionReturnType sets the value of the actionReturnType property. +func (o *CodeAction) SetActionReturnType(v element.Element) { + o.actionReturnType.Set(v) +} + +// ActionDefaultReturnName returns the value of the actionDefaultReturnName property. +func (o *CodeAction) ActionDefaultReturnName() string { + return o.actionDefaultReturnName.Get() +} + +// SetActionDefaultReturnName sets the value of the actionDefaultReturnName property. +func (o *CodeAction) SetActionDefaultReturnName(v string) { + o.actionDefaultReturnName.Set(v) +} + +// ModelerActionInfo returns the value of the modelerActionInfo property. +func (o *CodeAction) ModelerActionInfo() element.Element { + return o.modelerActionInfo.Get() +} + +// SetModelerActionInfo sets the value of the modelerActionInfo property. +func (o *CodeAction) SetModelerActionInfo(v element.Element) { + o.modelerActionInfo.Set(v) +} + +// ActionParametersItems returns the value of the actionParameters property. +func (o *CodeAction) ActionParametersItems() []element.Element { + return o.actionParameters.Items() +} + +// AddActionParameters appends a child element to the actionParameters list. +func (o *CodeAction) AddActionParameters(v element.Element) { + o.actionParameters.Append(v) +} + +// RemoveActionParameters removes the element at the given index from the actionParameters list. +func (o *CodeAction) RemoveActionParameters(index int) { + o.actionParameters.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CodeAction) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "ActionTypeParameters"); err == nil { + for _, child := range children { + o.actionTypeParameters.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ActionReturnType"); err == nil { + o.actionReturnType.SetFromDecode(child) + } + o.actionDefaultReturnName.Init(raw) + if child, err := codec.DecodeChild(raw, "ModelerActionInfo"); err == nil { + o.modelerActionInfo.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "ActionParameters"); err == nil { + for _, child := range children { + o.actionParameters.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// CodeActionParameter +// ──────────────────────────────────────────────────────── + +type CodeActionParameter struct { + element.Base + name *property.Primitive[string] + actionParameterType *property.Part[element.Element] + description *property.Primitive[string] + category *property.Primitive[string] + isRequired *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *CodeActionParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CodeActionParameter) SetName(v string) { + o.name.Set(v) +} + +// ActionParameterType returns the value of the actionParameterType property. +func (o *CodeActionParameter) ActionParameterType() element.Element { + return o.actionParameterType.Get() +} + +// SetActionParameterType sets the value of the actionParameterType property. +func (o *CodeActionParameter) SetActionParameterType(v element.Element) { + o.actionParameterType.Set(v) +} + +// Description returns the value of the description property. +func (o *CodeActionParameter) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *CodeActionParameter) SetDescription(v string) { + o.description.Set(v) +} + +// Category returns the value of the category property. +func (o *CodeActionParameter) Category() string { + return o.category.Get() +} + +// SetCategory sets the value of the category property. +func (o *CodeActionParameter) SetCategory(v string) { + o.category.Set(v) +} + +// IsRequired returns the value of the isRequired property. +func (o *CodeActionParameter) IsRequired() bool { + return o.isRequired.Get() +} + +// SetIsRequired sets the value of the isRequired property. +func (o *CodeActionParameter) SetIsRequired(v bool) { + o.isRequired.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CodeActionParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "ActionParameterType"); err == nil { + o.actionParameterType.SetFromDecode(child) + } + o.description.Init(raw) + o.category.Init(raw) + o.isRequired.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EntityType +// ──────────────────────────────────────────────────────── + +type EntityType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ConcreteEntityType +// ──────────────────────────────────────────────────────── + +type ConcreteEntityType struct { + element.Base + entity *property.ByNameRef[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ConcreteEntityType) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ConcreteEntityType) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConcreteEntityType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// CustomBlobDocumentParameterType +// ──────────────────────────────────────────────────────── + +type CustomBlobDocumentParameterType struct { + element.Base + customDocumentReadableTypeName *property.Primitive[string] + customDocumentTypeName *property.Primitive[string] +} + +// CustomDocumentReadableTypeName returns the value of the customDocumentReadableTypeName property. +func (o *CustomBlobDocumentParameterType) CustomDocumentReadableTypeName() string { + return o.customDocumentReadableTypeName.Get() +} + +// SetCustomDocumentReadableTypeName sets the value of the customDocumentReadableTypeName property. +func (o *CustomBlobDocumentParameterType) SetCustomDocumentReadableTypeName(v string) { + o.customDocumentReadableTypeName.Set(v) +} + +// CustomDocumentTypeName returns the value of the customDocumentTypeName property. +func (o *CustomBlobDocumentParameterType) CustomDocumentTypeName() string { + return o.customDocumentTypeName.Get() +} + +// SetCustomDocumentTypeName sets the value of the customDocumentTypeName property. +func (o *CustomBlobDocumentParameterType) SetCustomDocumentTypeName(v string) { + o.customDocumentTypeName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomBlobDocumentParameterType) InitFromRaw(raw bson.Raw) { + o.customDocumentReadableTypeName.Init(raw) + o.customDocumentTypeName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DateTimeType +// ──────────────────────────────────────────────────────── + +type DateTimeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DateTimeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// DecimalType +// ──────────────────────────────────────────────────────── + +type DecimalType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DecimalType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EntityTypeParameterType +// ──────────────────────────────────────────────────────── + +type EntityTypeParameterType struct { + element.Base + typeParameter *property.ByIdRef[element.Element] +} + +// TypeParameterRefID returns the value of the typeParameter property. +func (o *EntityTypeParameterType) TypeParameterRefID() element.ID { + return o.typeParameter.RefID() +} + +// SetTypeParameterID sets the value of the typeParameter property. +func (o *EntityTypeParameterType) SetTypeParameterID(v element.ID) { + o.typeParameter.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityTypeParameterType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("TypeParameterPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.typeParameter.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.typeParameter.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// EnumerationType +// ──────────────────────────────────────────────────────── + +type EnumerationType struct { + element.Base + enumeration *property.ByNameRef[element.Element] +} + +// EnumerationQualifiedName returns the value of the enumeration property. +func (o *EnumerationType) EnumerationQualifiedName() string { + return o.enumeration.QualifiedName() +} + +// SetEnumerationQualifiedName sets the value of the enumeration property. +func (o *EnumerationType) SetEnumerationQualifiedName(v string) { + o.enumeration.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EnumerationType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Enumeration"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.enumeration.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// FloatType +// ──────────────────────────────────────────────────────── + +type FloatType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FloatType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// IntegerType +// ──────────────────────────────────────────────────────── + +type IntegerType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IntegerType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ListType +// ──────────────────────────────────────────────────────── + +type ListType struct { + element.Base + parameter *property.Part[element.Element] +} + +// Parameter returns the value of the parameter property. +func (o *ListType) Parameter() element.Element { + return o.parameter.Get() +} + +// SetParameter sets the value of the parameter property. +func (o *ListType) SetParameter(v element.Element) { + o.parameter.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListType) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Parameter"); err == nil { + o.parameter.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowActionInfo +// ──────────────────────────────────────────────────────── + +type MicroflowActionInfo struct { + element.Base + caption *property.Primitive[string] + category *property.Primitive[string] + icon *property.ByNameRef[element.Element] + iconData *property.Primitive[string] + iconDataDark *property.Primitive[string] + imageData *property.Primitive[string] + imageDataDark *property.Primitive[string] +} + +// Caption returns the value of the caption property. +func (o *MicroflowActionInfo) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *MicroflowActionInfo) SetCaption(v string) { + o.caption.Set(v) +} + +// Category returns the value of the category property. +func (o *MicroflowActionInfo) Category() string { + return o.category.Get() +} + +// SetCategory sets the value of the category property. +func (o *MicroflowActionInfo) SetCategory(v string) { + o.category.Set(v) +} + +// IconQualifiedName returns the value of the icon property. +func (o *MicroflowActionInfo) IconQualifiedName() string { + return o.icon.QualifiedName() +} + +// SetIconQualifiedName sets the value of the icon property. +func (o *MicroflowActionInfo) SetIconQualifiedName(v string) { + o.icon.SetQualifiedName(v) +} + +// IconData returns the value of the iconData property. +func (o *MicroflowActionInfo) IconData() string { + return o.iconData.Get() +} + +// SetIconData sets the value of the iconData property. +func (o *MicroflowActionInfo) SetIconData(v string) { + o.iconData.Set(v) +} + +// IconDataDark returns the value of the iconDataDark property. +func (o *MicroflowActionInfo) IconDataDark() string { + return o.iconDataDark.Get() +} + +// SetIconDataDark sets the value of the iconDataDark property. +func (o *MicroflowActionInfo) SetIconDataDark(v string) { + o.iconDataDark.Set(v) +} + +// ImageData returns the value of the imageData property. +func (o *MicroflowActionInfo) ImageData() string { + return o.imageData.Get() +} + +// SetImageData sets the value of the imageData property. +func (o *MicroflowActionInfo) SetImageData(v string) { + o.imageData.Set(v) +} + +// ImageDataDark returns the value of the imageDataDark property. +func (o *MicroflowActionInfo) ImageDataDark() string { + return o.imageDataDark.Get() +} + +// SetImageDataDark sets the value of the imageDataDark property. +func (o *MicroflowActionInfo) SetImageDataDark(v string) { + o.imageDataDark.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowActionInfo) InitFromRaw(raw bson.Raw) { + o.caption.Init(raw) + o.category.Init(raw) + if val, err := raw.LookupErr("Icon"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.icon.SetFromDecode(s) + } + } + o.iconData.Init(raw) + o.iconDataDark.Init(raw) + o.imageData.Init(raw) + o.imageDataDark.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ParameterizedEntityType +// ──────────────────────────────────────────────────────── + +type ParameterizedEntityType struct { + element.Base + typeParameter *property.ByIdRef[element.Element] +} + +// TypeParameterRefID returns the value of the typeParameter property. +func (o *ParameterizedEntityType) TypeParameterRefID() element.ID { + return o.typeParameter.RefID() +} + +// SetTypeParameterID sets the value of the typeParameter property. +func (o *ParameterizedEntityType) SetTypeParameterID(v element.ID) { + o.typeParameter.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ParameterizedEntityType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("TypeParameterPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.typeParameter.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.typeParameter.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// StringTemplateParameterType +// ──────────────────────────────────────────────────────── + +type StringTemplateParameterType struct { + element.Base + grammar *property.Enum[string] +} + +// Grammar returns the value of the grammar property. +func (o *StringTemplateParameterType) Grammar() string { + return o.grammar.Get() +} + +// SetGrammar sets the value of the grammar property. +func (o *StringTemplateParameterType) SetGrammar(v string) { + o.grammar.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringTemplateParameterType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Grammar"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.grammar.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// StringType +// ──────────────────────────────────────────────────────── + +type StringType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// TypeParameter +// ──────────────────────────────────────────────────────── + +type TypeParameter struct { + element.Base + name *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *TypeParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TypeParameter) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TypeParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// VoidType +// ──────────────────────────────────────────────────────── + +type VoidType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VoidType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initBasicParameterType creates a BasicParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicParameterType() *BasicParameterType { + o := &BasicParameterType{} + o.SetTypeName("CodeActions$BasicParameterType") + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.propType}) + return o +} + +// NewBasicParameterType creates a new BasicParameterType for user code. Marked dirty (bit 63 = new element). +func NewBasicParameterType() *BasicParameterType { + o := initBasicParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBooleanType creates a BooleanType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBooleanType() *BooleanType { + o := &BooleanType{} + o.SetTypeName("CodeActions$BooleanType") + o.SetProperties([]element.Property{}) + return o +} + +// NewBooleanType creates a new BooleanType for user code. Marked dirty (bit 63 = new element). +func NewBooleanType() *BooleanType { + o := initBooleanType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConcreteEntityType creates a ConcreteEntityType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConcreteEntityType() *ConcreteEntityType { + o := &ConcreteEntityType{} + o.SetTypeName("CodeActions$ConcreteEntityType") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.entity}) + return o +} + +// NewConcreteEntityType creates a new ConcreteEntityType for user code. Marked dirty (bit 63 = new element). +func NewConcreteEntityType() *ConcreteEntityType { + o := initConcreteEntityType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomBlobDocumentParameterType creates a CustomBlobDocumentParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomBlobDocumentParameterType() *CustomBlobDocumentParameterType { + o := &CustomBlobDocumentParameterType{} + o.SetTypeName("CodeActions$CustomBlobDocumentParameterType") + o.customDocumentReadableTypeName = property.NewPrimitive[string]("CustomDocumentReadableTypeName", property.DecodeString) + o.customDocumentReadableTypeName.Bind(&o.Base, 0) + o.customDocumentTypeName = property.NewPrimitive[string]("CustomDocumentTypeName", property.DecodeString) + o.customDocumentTypeName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.customDocumentReadableTypeName, o.customDocumentTypeName}) + return o +} + +// NewCustomBlobDocumentParameterType creates a new CustomBlobDocumentParameterType for user code. Marked dirty (bit 63 = new element). +func NewCustomBlobDocumentParameterType() *CustomBlobDocumentParameterType { + o := initCustomBlobDocumentParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDateTimeType creates a DateTimeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDateTimeType() *DateTimeType { + o := &DateTimeType{} + o.SetTypeName("CodeActions$DateTimeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewDateTimeType creates a new DateTimeType for user code. Marked dirty (bit 63 = new element). +func NewDateTimeType() *DateTimeType { + o := initDateTimeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDecimalType creates a DecimalType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDecimalType() *DecimalType { + o := &DecimalType{} + o.SetTypeName("CodeActions$DecimalType") + o.SetProperties([]element.Property{}) + return o +} + +// NewDecimalType creates a new DecimalType for user code. Marked dirty (bit 63 = new element). +func NewDecimalType() *DecimalType { + o := initDecimalType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityTypeParameterType creates a EntityTypeParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityTypeParameterType() *EntityTypeParameterType { + o := &EntityTypeParameterType{} + o.SetTypeName("CodeActions$EntityTypeParameterType") + o.typeParameter = property.NewByIdRef[element.Element]("TypeParameterPointer") + o.typeParameter.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.typeParameter}) + return o +} + +// NewEntityTypeParameterType creates a new EntityTypeParameterType for user code. Marked dirty (bit 63 = new element). +func NewEntityTypeParameterType() *EntityTypeParameterType { + o := initEntityTypeParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEnumerationType creates a EnumerationType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEnumerationType() *EnumerationType { + o := &EnumerationType{} + o.SetTypeName("CodeActions$EnumerationType") + o.enumeration = property.NewByNameRef[element.Element]("Enumeration", "Enumerations$Enumeration") + o.enumeration.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.enumeration}) + return o +} + +// NewEnumerationType creates a new EnumerationType for user code. Marked dirty (bit 63 = new element). +func NewEnumerationType() *EnumerationType { + o := initEnumerationType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFloatType creates a FloatType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFloatType() *FloatType { + o := &FloatType{} + o.SetTypeName("CodeActions$FloatType") + o.SetProperties([]element.Property{}) + return o +} + +// NewFloatType creates a new FloatType for user code. Marked dirty (bit 63 = new element). +func NewFloatType() *FloatType { + o := initFloatType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIntegerType creates a IntegerType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIntegerType() *IntegerType { + o := &IntegerType{} + o.SetTypeName("CodeActions$IntegerType") + o.SetProperties([]element.Property{}) + return o +} + +// NewIntegerType creates a new IntegerType for user code. Marked dirty (bit 63 = new element). +func NewIntegerType() *IntegerType { + o := initIntegerType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListType creates a ListType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListType() *ListType { + o := &ListType{} + o.SetTypeName("CodeActions$ListType") + o.parameter = property.NewPart[element.Element]("Parameter") + o.parameter.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.parameter}) + return o +} + +// NewListType creates a new ListType for user code. Marked dirty (bit 63 = new element). +func NewListType() *ListType { + o := initListType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowActionInfo creates a MicroflowActionInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowActionInfo() *MicroflowActionInfo { + o := &MicroflowActionInfo{} + o.SetTypeName("CodeActions$MicroflowActionInfo") + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 0) + o.category = property.NewPrimitive[string]("Category", property.DecodeString) + o.category.Bind(&o.Base, 1) + o.icon = property.NewByNameRef[element.Element]("Icon", "Images$Image") + o.icon.Bind(&o.Base, 2) + o.iconData = property.NewPrimitive[string]("IconData", property.DecodeString) + o.iconData.Bind(&o.Base, 3) + o.iconDataDark = property.NewPrimitive[string]("IconDataDark", property.DecodeString) + o.iconDataDark.Bind(&o.Base, 4) + o.imageData = property.NewPrimitive[string]("ImageData", property.DecodeString) + o.imageData.Bind(&o.Base, 5) + o.imageDataDark = property.NewPrimitive[string]("ImageDataDark", property.DecodeString) + o.imageDataDark.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.caption, o.category, o.icon, o.iconData, o.iconDataDark, o.imageData, o.imageDataDark}) + return o +} + +// NewMicroflowActionInfo creates a new MicroflowActionInfo for user code. Marked dirty (bit 63 = new element). +func NewMicroflowActionInfo() *MicroflowActionInfo { + o := initMicroflowActionInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initParameterizedEntityType creates a ParameterizedEntityType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initParameterizedEntityType() *ParameterizedEntityType { + o := &ParameterizedEntityType{} + o.SetTypeName("CodeActions$ParameterizedEntityType") + o.typeParameter = property.NewByIdRef[element.Element]("TypeParameterPointer") + o.typeParameter.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.typeParameter}) + return o +} + +// NewParameterizedEntityType creates a new ParameterizedEntityType for user code. Marked dirty (bit 63 = new element). +func NewParameterizedEntityType() *ParameterizedEntityType { + o := initParameterizedEntityType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringTemplateParameterType creates a StringTemplateParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringTemplateParameterType() *StringTemplateParameterType { + o := &StringTemplateParameterType{} + o.SetTypeName("CodeActions$StringTemplateParameterType") + o.grammar = property.NewEnum[string]("Grammar") + o.grammar.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.grammar}) + return o +} + +// NewStringTemplateParameterType creates a new StringTemplateParameterType for user code. Marked dirty (bit 63 = new element). +func NewStringTemplateParameterType() *StringTemplateParameterType { + o := initStringTemplateParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringType creates a StringType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringType() *StringType { + o := &StringType{} + o.SetTypeName("CodeActions$StringType") + o.SetProperties([]element.Property{}) + return o +} + +// NewStringType creates a new StringType for user code. Marked dirty (bit 63 = new element). +func NewStringType() *StringType { + o := initStringType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTypeParameter creates a TypeParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTypeParameter() *TypeParameter { + o := &TypeParameter{} + o.SetTypeName("CodeActions$TypeParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.name}) + return o +} + +// NewTypeParameter creates a new TypeParameter for user code. Marked dirty (bit 63 = new element). +func NewTypeParameter() *TypeParameter { + o := initTypeParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initVoidType creates a VoidType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initVoidType() *VoidType { + o := &VoidType{} + o.SetTypeName("CodeActions$VoidType") + o.SetProperties([]element.Property{}) + return o +} + +// NewVoidType creates a new VoidType for user code. Marked dirty (bit 63 = new element). +func NewVoidType() *VoidType { + o := initVoidType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("CodeActions$BasicParameterType", func() element.Element { + return initBasicParameterType() + }) + codec.DefaultRegistry.Register("CodeActions$BooleanType", func() element.Element { + return initBooleanType() + }) + codec.DefaultRegistry.Register("CodeActions$ConcreteEntityType", func() element.Element { + return initConcreteEntityType() + }) + codec.DefaultRegistry.Register("CodeActions$CustomBlobDocumentParameterType", func() element.Element { + return initCustomBlobDocumentParameterType() + }) + codec.DefaultRegistry.Register("CodeActions$DateTimeType", func() element.Element { + return initDateTimeType() + }) + codec.DefaultRegistry.Register("CodeActions$DecimalType", func() element.Element { + return initDecimalType() + }) + codec.DefaultRegistry.Register("CodeActions$EntityTypeParameterType", func() element.Element { + return initEntityTypeParameterType() + }) + codec.DefaultRegistry.Register("CodeActions$EnumerationType", func() element.Element { + return initEnumerationType() + }) + codec.DefaultRegistry.Register("CodeActions$FloatType", func() element.Element { + return initFloatType() + }) + codec.DefaultRegistry.Register("CodeActions$IntegerType", func() element.Element { + return initIntegerType() + }) + codec.DefaultRegistry.Register("CodeActions$ListType", func() element.Element { + return initListType() + }) + codec.DefaultRegistry.Register("CodeActions$MicroflowActionInfo", func() element.Element { + return initMicroflowActionInfo() + }) + codec.DefaultRegistry.Register("CodeActions$ParameterizedEntityType", func() element.Element { + return initParameterizedEntityType() + }) + codec.DefaultRegistry.Register("CodeActions$StringTemplateParameterType", func() element.Element { + return initStringTemplateParameterType() + }) + codec.DefaultRegistry.Register("CodeActions$StringType", func() element.Element { + return initStringType() + }) + codec.DefaultRegistry.Register("CodeActions$TypeParameter", func() element.Element { + return initTypeParameter() + }) + codec.DefaultRegistry.Register("CodeActions$VoidType", func() element.Element { + return initVoidType() + }) +} diff --git a/modelsdk/gen/codeactions/version.go b/modelsdk/gen/codeactions/version.go new file mode 100644 index 00000000..69d45f7b --- /dev/null +++ b/modelsdk/gen/codeactions/version.go @@ -0,0 +1,86 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package codeactions + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "CodeActions$BasicParameterType": { + Properties: map[string]version.PropertyVersionInfo{ + "type": {Required: true, Public: true}, + }, + }, + "CodeActions$CodeAction": { + Properties: map[string]version.PropertyVersionInfo{ + "actionDefaultReturnName": {Introduced: "9.23.0", Public: true}, + "actionParameters": {Introduced: "7.21.0", Public: true}, + "actionReturnType": {Introduced: "7.21.0", Required: true, Public: true}, + "actionTypeParameters": {Introduced: "7.21.0", Public: true}, + "modelerActionInfo": {Introduced: "7.21.0", Public: true}, + }, + }, + "CodeActions$CodeActionParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "actionParameterType": {Introduced: "7.21.0", Required: true, Public: true}, + "category": {Introduced: "7.18.0"}, + "description": {Introduced: "6.10.0", Public: true}, + "isRequired": {Introduced: "9.17.0", Public: true}, + "name": {Public: true}, + }, + }, + "CodeActions$ConcreteEntityType": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true, Public: true}, + }, + }, + "CodeActions$CustomBlobDocumentParameterType": { + Properties: map[string]version.PropertyVersionInfo{ + "customDocumentReadableTypeName": {Public: true}, + "customDocumentTypeName": {Public: true}, + }, + }, + "CodeActions$EntityTypeParameterType": { + Properties: map[string]version.PropertyVersionInfo{ + "typeParameter": {Public: true}, + }, + }, + "CodeActions$EnumerationType": { + Properties: map[string]version.PropertyVersionInfo{ + "enumeration": {Required: true, Public: true}, + }, + }, + "CodeActions$ListType": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true, Public: true}, + }, + }, + "CodeActions$MicroflowActionInfo": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Public: true}, + "category": {Public: true}, + "icon": {Deleted: "9.10.0", Public: true}, + "iconData": {Introduced: "9.10.0"}, + "iconDataDark": {Introduced: "9.10.0"}, + "imageData": {Introduced: "9.6.0", Public: true}, + "imageDataDark": {Introduced: "9.10.0"}, + }, + }, + "CodeActions$ParameterizedEntityType": { + Properties: map[string]version.PropertyVersionInfo{ + "typeParameter": {Required: true, Public: true}, + }, + }, + "CodeActions$StringTemplateParameterType": { + Properties: map[string]version.PropertyVersionInfo{ + "grammar": {Introduced: "8.8.0", Public: true}, + }, + }, + "CodeActions$TypeParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + }, + }, +} diff --git a/modelsdk/gen/connectorkit/enums.go b/modelsdk/gen/connectorkit/enums.go new file mode 100644 index 00000000..9d6cc5f3 --- /dev/null +++ b/modelsdk/gen/connectorkit/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package connectorkit diff --git a/modelsdk/gen/connectorkit/refs.go b/modelsdk/gen/connectorkit/refs.go new file mode 100644 index 00000000..3f502607 --- /dev/null +++ b/modelsdk/gen/connectorkit/refs.go @@ -0,0 +1,25 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package connectorkit + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("ConnectorKit$Connector", []codec.RefMeta{ + {Prop: "Connector", Kind: codec.RefByName, Target: "ConnectorKit$ConnectorType"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ConnectorKit$ConnectorAction", []codec.RefMeta{ + {Prop: "JavaAction", Kind: codec.RefByName, Target: "JavaActions$JavaAction"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ConnectorKit$ConnectorActionCallAction", []codec.RefMeta{ + {Prop: "ConnectorAction", Kind: codec.RefByName, Target: "ConnectorKit$ConnectorAction"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ConnectorKit$ConnectorActionParameterMapping", []codec.RefMeta{ + {Prop: "JavaActionParameter", Kind: codec.RefByName, Target: "JavaActions$JavaActionParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ConnectorKit$ConnectorPropertyMapping", []codec.RefMeta{ + {Prop: "ConnectorProperty", Kind: codec.RefByName, Target: "ConnectorKit$ConnectorProperty"}, + }) +} diff --git a/modelsdk/gen/connectorkit/types.go b/modelsdk/gen/connectorkit/types.go new file mode 100644 index 00000000..46934875 --- /dev/null +++ b/modelsdk/gen/connectorkit/types.go @@ -0,0 +1,825 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package connectorkit + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Connector +// ──────────────────────────────────────────────────────── + +type Connector struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + connector *property.ByNameRef[element.Element] + propertyMapping *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *Connector) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Connector) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Connector) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Connector) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Connector) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Connector) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Connector) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Connector) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ConnectorQualifiedName returns the value of the connector property. +func (o *Connector) ConnectorQualifiedName() string { + return o.connector.QualifiedName() +} + +// SetConnectorQualifiedName sets the value of the connector property. +func (o *Connector) SetConnectorQualifiedName(v string) { + o.connector.SetQualifiedName(v) +} + +// PropertyMappingItems returns the value of the propertyMapping property. +func (o *Connector) PropertyMappingItems() []element.Element { + return o.propertyMapping.Items() +} + +// AddPropertyMapping appends a child element to the propertyMapping list. +func (o *Connector) AddPropertyMapping(v element.Element) { + o.propertyMapping.Append(v) +} + +// RemovePropertyMapping removes the element at the given index from the propertyMapping list. +func (o *Connector) RemovePropertyMapping(index int) { + o.propertyMapping.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Connector) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Connector"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.connector.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "PropertyMapping"); err == nil { + for _, child := range children { + o.propertyMapping.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ConnectorAction +// ──────────────────────────────────────────────────────── + +type ConnectorAction struct { + element.Base + name *property.Primitive[string] + caption *property.Primitive[string] + documentation *property.Primitive[string] + icon *property.Primitive[string] + iconDark *property.Primitive[string] + javaAction *property.ByNameRef[element.Element] +} + +// Name returns the value of the name property. +func (o *ConnectorAction) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConnectorAction) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ConnectorAction) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ConnectorAction) SetCaption(v string) { + o.caption.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ConnectorAction) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ConnectorAction) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Icon returns the value of the icon property. +func (o *ConnectorAction) Icon() string { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *ConnectorAction) SetIcon(v string) { + o.icon.Set(v) +} + +// IconDark returns the value of the iconDark property. +func (o *ConnectorAction) IconDark() string { + return o.iconDark.Get() +} + +// SetIconDark sets the value of the iconDark property. +func (o *ConnectorAction) SetIconDark(v string) { + o.iconDark.Set(v) +} + +// JavaActionQualifiedName returns the value of the javaAction property. +func (o *ConnectorAction) JavaActionQualifiedName() string { + return o.javaAction.QualifiedName() +} + +// SetJavaActionQualifiedName sets the value of the javaAction property. +func (o *ConnectorAction) SetJavaActionQualifiedName(v string) { + o.javaAction.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectorAction) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.caption.Init(raw) + o.documentation.Init(raw) + o.icon.Init(raw) + o.iconDark.Init(raw) + if val, err := raw.LookupErr("JavaAction"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.javaAction.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ConnectorActionCallAction +// ──────────────────────────────────────────────────────── + +type ConnectorActionCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + connectorAction *property.ByNameRef[element.Element] + outputVariableName *property.Primitive[string] + parameterMappings *property.PartList[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ConnectorActionCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ConnectorActionCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// ConnectorActionQualifiedName returns the value of the connectorAction property. +func (o *ConnectorActionCallAction) ConnectorActionQualifiedName() string { + return o.connectorAction.QualifiedName() +} + +// SetConnectorActionQualifiedName sets the value of the connectorAction property. +func (o *ConnectorActionCallAction) SetConnectorActionQualifiedName(v string) { + o.connectorAction.SetQualifiedName(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *ConnectorActionCallAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *ConnectorActionCallAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *ConnectorActionCallAction) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *ConnectorActionCallAction) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *ConnectorActionCallAction) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectorActionCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.errorHandlingType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ConnectorAction"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.connectorAction.SetFromDecode(s) + } + } + o.outputVariableName.Init(raw) + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ConnectorActionParameterMapping +// ──────────────────────────────────────────────────────── + +type ConnectorActionParameterMapping struct { + element.Base + javaActionParameter *property.ByNameRef[element.Element] + parameterValueExpression *property.Primitive[string] +} + +// JavaActionParameterQualifiedName returns the value of the javaActionParameter property. +func (o *ConnectorActionParameterMapping) JavaActionParameterQualifiedName() string { + return o.javaActionParameter.QualifiedName() +} + +// SetJavaActionParameterQualifiedName sets the value of the javaActionParameter property. +func (o *ConnectorActionParameterMapping) SetJavaActionParameterQualifiedName(v string) { + o.javaActionParameter.SetQualifiedName(v) +} + +// ParameterValueExpression returns the value of the parameterValueExpression property. +func (o *ConnectorActionParameterMapping) ParameterValueExpression() string { + return o.parameterValueExpression.Get() +} + +// SetParameterValueExpression sets the value of the parameterValueExpression property. +func (o *ConnectorActionParameterMapping) SetParameterValueExpression(v string) { + o.parameterValueExpression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectorActionParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("JavaActionParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.javaActionParameter.SetFromDecode(s) + } + } + o.parameterValueExpression.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConnectorProperty +// ──────────────────────────────────────────────────────── + +type ConnectorProperty struct { + element.Base + name *property.Primitive[string] + propertyType *property.Part[element.Element] + isOptional *property.Primitive[bool] + description *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *ConnectorProperty) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConnectorProperty) SetName(v string) { + o.name.Set(v) +} + +// PropertyType returns the value of the propertyType property. +func (o *ConnectorProperty) PropertyType() element.Element { + return o.propertyType.Get() +} + +// SetPropertyType sets the value of the propertyType property. +func (o *ConnectorProperty) SetPropertyType(v element.Element) { + o.propertyType.Set(v) +} + +// IsOptional returns the value of the isOptional property. +func (o *ConnectorProperty) IsOptional() bool { + return o.isOptional.Get() +} + +// SetIsOptional sets the value of the isOptional property. +func (o *ConnectorProperty) SetIsOptional(v bool) { + o.isOptional.Set(v) +} + +// Description returns the value of the description property. +func (o *ConnectorProperty) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *ConnectorProperty) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectorProperty) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "PropertyType"); err == nil { + o.propertyType.SetFromDecode(child) + } + o.isOptional.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConnectorPropertyMapping +// ──────────────────────────────────────────────────────── + +type ConnectorPropertyMapping struct { + element.Base + connectorProperty *property.ByNameRef[element.Element] + propertyValueExpression *property.Primitive[string] +} + +// ConnectorPropertyQualifiedName returns the value of the connectorProperty property. +func (o *ConnectorPropertyMapping) ConnectorPropertyQualifiedName() string { + return o.connectorProperty.QualifiedName() +} + +// SetConnectorPropertyQualifiedName sets the value of the connectorProperty property. +func (o *ConnectorPropertyMapping) SetConnectorPropertyQualifiedName(v string) { + o.connectorProperty.SetQualifiedName(v) +} + +// PropertyValueExpression returns the value of the propertyValueExpression property. +func (o *ConnectorPropertyMapping) PropertyValueExpression() string { + return o.propertyValueExpression.Get() +} + +// SetPropertyValueExpression sets the value of the propertyValueExpression property. +func (o *ConnectorPropertyMapping) SetPropertyValueExpression(v string) { + o.propertyValueExpression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectorPropertyMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ConnectorProperty"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.connectorProperty.SetFromDecode(s) + } + } + o.propertyValueExpression.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConnectorType +// ──────────────────────────────────────────────────────── + +type ConnectorType struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + connectorName *property.Primitive[string] + description *property.Primitive[string] + icon *property.Primitive[string] + iconDark *property.Primitive[string] + version *property.Primitive[string] + connectorActions *property.PartList[element.Element] + connectorProperties *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *ConnectorType) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConnectorType) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ConnectorType) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ConnectorType) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ConnectorType) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ConnectorType) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ConnectorType) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ConnectorType) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ConnectorName returns the value of the connectorName property. +func (o *ConnectorType) ConnectorName() string { + return o.connectorName.Get() +} + +// SetConnectorName sets the value of the connectorName property. +func (o *ConnectorType) SetConnectorName(v string) { + o.connectorName.Set(v) +} + +// Description returns the value of the description property. +func (o *ConnectorType) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *ConnectorType) SetDescription(v string) { + o.description.Set(v) +} + +// Icon returns the value of the icon property. +func (o *ConnectorType) Icon() string { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *ConnectorType) SetIcon(v string) { + o.icon.Set(v) +} + +// IconDark returns the value of the iconDark property. +func (o *ConnectorType) IconDark() string { + return o.iconDark.Get() +} + +// SetIconDark sets the value of the iconDark property. +func (o *ConnectorType) SetIconDark(v string) { + o.iconDark.Set(v) +} + +// Version returns the value of the version property. +func (o *ConnectorType) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *ConnectorType) SetVersion(v string) { + o.version.Set(v) +} + +// ConnectorActionsItems returns the value of the connectorActions property. +func (o *ConnectorType) ConnectorActionsItems() []element.Element { + return o.connectorActions.Items() +} + +// AddConnectorActions appends a child element to the connectorActions list. +func (o *ConnectorType) AddConnectorActions(v element.Element) { + o.connectorActions.Append(v) +} + +// RemoveConnectorActions removes the element at the given index from the connectorActions list. +func (o *ConnectorType) RemoveConnectorActions(index int) { + o.connectorActions.Remove(index) +} + +// ConnectorPropertiesItems returns the value of the connectorProperties property. +func (o *ConnectorType) ConnectorPropertiesItems() []element.Element { + return o.connectorProperties.Items() +} + +// AddConnectorProperties appends a child element to the connectorProperties list. +func (o *ConnectorType) AddConnectorProperties(v element.Element) { + o.connectorProperties.Append(v) +} + +// RemoveConnectorProperties removes the element at the given index from the connectorProperties list. +func (o *ConnectorType) RemoveConnectorProperties(index int) { + o.connectorProperties.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectorType) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.connectorName.Init(raw) + o.description.Init(raw) + o.icon.Init(raw) + o.iconDark.Init(raw) + o.version.Init(raw) + if children, err := codec.DecodeChildren(raw, "ConnectorActions"); err == nil { + for _, child := range children { + o.connectorActions.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "ConnectorProperties"); err == nil { + for _, child := range children { + o.connectorProperties.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initConnector creates a Connector with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnector() *Connector { + o := &Connector{} + o.SetTypeName("ConnectorKit$Connector") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.connector = property.NewByNameRef[element.Element]("Connector", "ConnectorKit$ConnectorType") + o.connector.Bind(&o.Base, 4) + o.propertyMapping = property.NewPartList[element.Element]("PropertyMapping") + o.propertyMapping.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.connector, o.propertyMapping}) + return o +} + +// NewConnector creates a new Connector for user code. Marked dirty (bit 63 = new element). +func NewConnector() *Connector { + o := initConnector() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConnectorAction creates a ConnectorAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnectorAction() *ConnectorAction { + o := &ConnectorAction{} + o.SetTypeName("ConnectorKit$ConnectorAction") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 1) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 2) + o.icon = property.NewPrimitive[string]("Icon", property.DecodeString) + o.icon.Bind(&o.Base, 3) + o.iconDark = property.NewPrimitive[string]("IconDark", property.DecodeString) + o.iconDark.Bind(&o.Base, 4) + o.javaAction = property.NewByNameRef[element.Element]("JavaAction", "JavaActions$JavaAction") + o.javaAction.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.caption, o.documentation, o.icon, o.iconDark, o.javaAction}) + return o +} + +// NewConnectorAction creates a new ConnectorAction for user code. Marked dirty (bit 63 = new element). +func NewConnectorAction() *ConnectorAction { + o := initConnectorAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConnectorActionCallAction creates a ConnectorActionCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnectorActionCallAction() *ConnectorActionCallAction { + o := &ConnectorActionCallAction{} + o.SetTypeName("ConnectorKit$ConnectorActionCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.connectorAction = property.NewByNameRef[element.Element]("ConnectorAction", "ConnectorKit$ConnectorAction") + o.connectorAction.Bind(&o.Base, 1) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 2) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.connectorAction, o.outputVariableName, o.parameterMappings}) + return o +} + +// NewConnectorActionCallAction creates a new ConnectorActionCallAction for user code. Marked dirty (bit 63 = new element). +func NewConnectorActionCallAction() *ConnectorActionCallAction { + o := initConnectorActionCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConnectorActionParameterMapping creates a ConnectorActionParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnectorActionParameterMapping() *ConnectorActionParameterMapping { + o := &ConnectorActionParameterMapping{} + o.SetTypeName("ConnectorKit$ConnectorActionParameterMapping") + o.javaActionParameter = property.NewByNameRef[element.Element]("JavaActionParameter", "JavaActions$JavaActionParameter") + o.javaActionParameter.Bind(&o.Base, 0) + o.parameterValueExpression = property.NewPrimitive[string]("ParameterValueExpression", property.DecodeString) + o.parameterValueExpression.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.javaActionParameter, o.parameterValueExpression}) + return o +} + +// NewConnectorActionParameterMapping creates a new ConnectorActionParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewConnectorActionParameterMapping() *ConnectorActionParameterMapping { + o := initConnectorActionParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConnectorProperty creates a ConnectorProperty with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnectorProperty() *ConnectorProperty { + o := &ConnectorProperty{} + o.SetTypeName("ConnectorKit$ConnectorProperty") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propertyType = property.NewPart[element.Element]("PropertyType") + o.propertyType.Bind(&o.Base, 1) + o.isOptional = property.NewPrimitive[bool]("IsOptional", property.DecodeBool) + o.isOptional.Bind(&o.Base, 2) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.name, o.propertyType, o.isOptional, o.description}) + return o +} + +// NewConnectorProperty creates a new ConnectorProperty for user code. Marked dirty (bit 63 = new element). +func NewConnectorProperty() *ConnectorProperty { + o := initConnectorProperty() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConnectorPropertyMapping creates a ConnectorPropertyMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnectorPropertyMapping() *ConnectorPropertyMapping { + o := &ConnectorPropertyMapping{} + o.SetTypeName("ConnectorKit$ConnectorPropertyMapping") + o.connectorProperty = property.NewByNameRef[element.Element]("ConnectorProperty", "ConnectorKit$ConnectorProperty") + o.connectorProperty.Bind(&o.Base, 0) + o.propertyValueExpression = property.NewPrimitive[string]("PropertyValueExpression", property.DecodeString) + o.propertyValueExpression.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.connectorProperty, o.propertyValueExpression}) + return o +} + +// NewConnectorPropertyMapping creates a new ConnectorPropertyMapping for user code. Marked dirty (bit 63 = new element). +func NewConnectorPropertyMapping() *ConnectorPropertyMapping { + o := initConnectorPropertyMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConnectorType creates a ConnectorType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnectorType() *ConnectorType { + o := &ConnectorType{} + o.SetTypeName("ConnectorKit$ConnectorType") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.connectorName = property.NewPrimitive[string]("ConnectorName", property.DecodeString) + o.connectorName.Bind(&o.Base, 4) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 5) + o.icon = property.NewPrimitive[string]("Icon", property.DecodeString) + o.icon.Bind(&o.Base, 6) + o.iconDark = property.NewPrimitive[string]("IconDark", property.DecodeString) + o.iconDark.Bind(&o.Base, 7) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 8) + o.connectorActions = property.NewPartList[element.Element]("ConnectorActions") + o.connectorActions.Bind(&o.Base, 9) + o.connectorProperties = property.NewPartList[element.Element]("ConnectorProperties") + o.connectorProperties.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.connectorName, o.description, o.icon, o.iconDark, o.version, o.connectorActions, o.connectorProperties}) + return o +} + +// NewConnectorType creates a new ConnectorType for user code. Marked dirty (bit 63 = new element). +func NewConnectorType() *ConnectorType { + o := initConnectorType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("ConnectorKit$Connector", func() element.Element { + return initConnector() + }) + codec.DefaultRegistry.Register("ConnectorKit$ConnectorAction", func() element.Element { + return initConnectorAction() + }) + codec.DefaultRegistry.Register("ConnectorKit$ConnectorActionCallAction", func() element.Element { + return initConnectorActionCallAction() + }) + codec.DefaultRegistry.Register("ConnectorKit$ConnectorActionParameterMapping", func() element.Element { + return initConnectorActionParameterMapping() + }) + codec.DefaultRegistry.Register("ConnectorKit$ConnectorProperty", func() element.Element { + return initConnectorProperty() + }) + codec.DefaultRegistry.Register("ConnectorKit$ConnectorPropertyMapping", func() element.Element { + return initConnectorPropertyMapping() + }) + codec.DefaultRegistry.Register("ConnectorKit$ConnectorType", func() element.Element { + return initConnectorType() + }) +} diff --git a/modelsdk/gen/connectorkit/version.go b/modelsdk/gen/connectorkit/version.go new file mode 100644 index 00000000..0d757a45 --- /dev/null +++ b/modelsdk/gen/connectorkit/version.go @@ -0,0 +1,38 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package connectorkit + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "ConnectorKit$ConnectorAction": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + }, + }, + "ConnectorKit$ConnectorActionParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "javaActionParameter": {Required: true}, + }, + }, + "ConnectorKit$ConnectorProperty": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "propertyType": {Required: true}, + }, + }, + "ConnectorKit$ConnectorPropertyMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "connectorProperty": {Required: true}, + }, + }, + "ConnectorKit$ConnectorType": { + Properties: map[string]version.PropertyVersionInfo{ + "connectorActions": {Public: true}, + "connectorProperties": {Public: true}, + }, + }, +} diff --git a/modelsdk/gen/constants/enums.go b/modelsdk/gen/constants/enums.go new file mode 100644 index 00000000..d28247fc --- /dev/null +++ b/modelsdk/gen/constants/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package constants diff --git a/modelsdk/gen/constants/refs.go b/modelsdk/gen/constants/refs.go new file mode 100644 index 00000000..d28247fc --- /dev/null +++ b/modelsdk/gen/constants/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package constants diff --git a/modelsdk/gen/constants/types.go b/modelsdk/gen/constants/types.go new file mode 100644 index 00000000..cf28711b --- /dev/null +++ b/modelsdk/gen/constants/types.go @@ -0,0 +1,179 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package constants + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Constant +// ──────────────────────────────────────────────────────── + +type Constant struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + dataType *property.Primitive[string] + propType *property.Part[element.Element] + defaultValue *property.Primitive[string] + exposedToClient *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *Constant) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Constant) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Constant) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Constant) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Constant) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Constant) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Constant) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Constant) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// DataType returns the value of the dataType property. +func (o *Constant) DataType() string { + return o.dataType.Get() +} + +// SetDataType sets the value of the dataType property. +func (o *Constant) SetDataType(v string) { + o.dataType.Set(v) +} + +// Type returns the value of the type property. +func (o *Constant) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *Constant) SetType(v element.Element) { + o.propType.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *Constant) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *Constant) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// ExposedToClient returns the value of the exposedToClient property. +func (o *Constant) ExposedToClient() bool { + return o.exposedToClient.Get() +} + +// SetExposedToClient sets the value of the exposedToClient property. +func (o *Constant) SetExposedToClient(v bool) { + o.exposedToClient.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Constant) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.dataType.Init(raw) + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } + o.defaultValue.Init(raw) + o.exposedToClient.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initConstant creates a Constant with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConstant() *Constant { + o := &Constant{} + o.SetTypeName("Constants$Constant") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.dataType = property.NewPrimitive[string]("DataType", property.DecodeString) + o.dataType.Bind(&o.Base, 4) + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 5) + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 6) + o.exposedToClient = property.NewPrimitive[bool]("ExposedToClient", property.DecodeBool) + o.exposedToClient.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.dataType, o.propType, o.defaultValue, o.exposedToClient}) + return o +} + +// NewConstant creates a new Constant for user code. Marked dirty (bit 63 = new element). +func NewConstant() *Constant { + o := initConstant() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Constants$Constant", func() element.Element { + return initConstant() + }) +} diff --git a/modelsdk/gen/constants/version.go b/modelsdk/gen/constants/version.go new file mode 100644 index 00000000..838244c8 --- /dev/null +++ b/modelsdk/gen/constants/version.go @@ -0,0 +1,18 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package constants + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Constants$Constant": { + Properties: map[string]version.PropertyVersionInfo{ + "dataType": {Deleted: "7.9.0"}, + "exposedToClient": {Introduced: "8.2.0"}, + "type": {Introduced: "7.9.0", Required: true, Public: true}, + }, + }, +} diff --git a/modelsdk/gen/customblobdocuments/enums.go b/modelsdk/gen/customblobdocuments/enums.go new file mode 100644 index 00000000..fc5549b3 --- /dev/null +++ b/modelsdk/gen/customblobdocuments/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customblobdocuments diff --git a/modelsdk/gen/customblobdocuments/refs.go b/modelsdk/gen/customblobdocuments/refs.go new file mode 100644 index 00000000..fc5549b3 --- /dev/null +++ b/modelsdk/gen/customblobdocuments/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customblobdocuments diff --git a/modelsdk/gen/customblobdocuments/types.go b/modelsdk/gen/customblobdocuments/types.go new file mode 100644 index 00000000..03308406 --- /dev/null +++ b/modelsdk/gen/customblobdocuments/types.go @@ -0,0 +1,227 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customblobdocuments + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// CustomBlobDocument +// ──────────────────────────────────────────────────────── + +type CustomBlobDocument struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + customDocumentType *property.Primitive[string] + contents *property.Primitive[string] + metadata *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *CustomBlobDocument) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CustomBlobDocument) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *CustomBlobDocument) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *CustomBlobDocument) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *CustomBlobDocument) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *CustomBlobDocument) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *CustomBlobDocument) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *CustomBlobDocument) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CustomDocumentType returns the value of the customDocumentType property. +func (o *CustomBlobDocument) CustomDocumentType() string { + return o.customDocumentType.Get() +} + +// SetCustomDocumentType sets the value of the customDocumentType property. +func (o *CustomBlobDocument) SetCustomDocumentType(v string) { + o.customDocumentType.Set(v) +} + +// Contents returns the value of the contents property. +func (o *CustomBlobDocument) Contents() string { + return o.contents.Get() +} + +// SetContents sets the value of the contents property. +func (o *CustomBlobDocument) SetContents(v string) { + o.contents.Set(v) +} + +// Metadata returns the value of the metadata property. +func (o *CustomBlobDocument) Metadata() element.Element { + return o.metadata.Get() +} + +// SetMetadata sets the value of the metadata property. +func (o *CustomBlobDocument) SetMetadata(v element.Element) { + o.metadata.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomBlobDocument) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.customDocumentType.Init(raw) + o.contents.Init(raw) + if child, err := codec.DecodeChild(raw, "Metadata"); err == nil { + o.metadata.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// CustomBlobDocumentMetadata +// ──────────────────────────────────────────────────────── + +type CustomBlobDocumentMetadata struct { + element.Base + createdByExtension *property.Primitive[string] + readableTypeName *property.Primitive[string] +} + +// CreatedByExtension returns the value of the createdByExtension property. +func (o *CustomBlobDocumentMetadata) CreatedByExtension() string { + return o.createdByExtension.Get() +} + +// SetCreatedByExtension sets the value of the createdByExtension property. +func (o *CustomBlobDocumentMetadata) SetCreatedByExtension(v string) { + o.createdByExtension.Set(v) +} + +// ReadableTypeName returns the value of the readableTypeName property. +func (o *CustomBlobDocumentMetadata) ReadableTypeName() string { + return o.readableTypeName.Get() +} + +// SetReadableTypeName sets the value of the readableTypeName property. +func (o *CustomBlobDocumentMetadata) SetReadableTypeName(v string) { + o.readableTypeName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomBlobDocumentMetadata) InitFromRaw(raw bson.Raw) { + o.createdByExtension.Init(raw) + o.readableTypeName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initCustomBlobDocument creates a CustomBlobDocument with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomBlobDocument() *CustomBlobDocument { + o := &CustomBlobDocument{} + o.SetTypeName("CustomBlobDocuments$CustomBlobDocument") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.customDocumentType = property.NewPrimitive[string]("CustomDocumentType", property.DecodeString) + o.customDocumentType.Bind(&o.Base, 4) + o.contents = property.NewPrimitive[string]("Contents", property.DecodeString) + o.contents.Bind(&o.Base, 5) + o.metadata = property.NewPart[element.Element]("Metadata") + o.metadata.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.customDocumentType, o.contents, o.metadata}) + return o +} + +// NewCustomBlobDocument creates a new CustomBlobDocument for user code. Marked dirty (bit 63 = new element). +func NewCustomBlobDocument() *CustomBlobDocument { + o := initCustomBlobDocument() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomBlobDocumentMetadata creates a CustomBlobDocumentMetadata with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomBlobDocumentMetadata() *CustomBlobDocumentMetadata { + o := &CustomBlobDocumentMetadata{} + o.SetTypeName("CustomBlobDocuments$CustomBlobDocumentMetadata") + o.createdByExtension = property.NewPrimitive[string]("CreatedByExtension", property.DecodeString) + o.createdByExtension.Bind(&o.Base, 0) + o.readableTypeName = property.NewPrimitive[string]("ReadableTypeName", property.DecodeString) + o.readableTypeName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.createdByExtension, o.readableTypeName}) + return o +} + +// NewCustomBlobDocumentMetadata creates a new CustomBlobDocumentMetadata for user code. Marked dirty (bit 63 = new element). +func NewCustomBlobDocumentMetadata() *CustomBlobDocumentMetadata { + o := initCustomBlobDocumentMetadata() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("CustomBlobDocuments$CustomBlobDocument", func() element.Element { + return initCustomBlobDocument() + }) + codec.DefaultRegistry.Register("CustomBlobDocuments$CustomBlobDocumentMetadata", func() element.Element { + return initCustomBlobDocumentMetadata() + }) +} diff --git a/modelsdk/gen/customblobdocuments/version.go b/modelsdk/gen/customblobdocuments/version.go new file mode 100644 index 00000000..68212add --- /dev/null +++ b/modelsdk/gen/customblobdocuments/version.go @@ -0,0 +1,16 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customblobdocuments + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "CustomBlobDocuments$CustomBlobDocument": { + Properties: map[string]version.PropertyVersionInfo{ + "metadata": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/customicons/enums.go b/modelsdk/gen/customicons/enums.go new file mode 100644 index 00000000..480047ee --- /dev/null +++ b/modelsdk/gen/customicons/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customicons diff --git a/modelsdk/gen/customicons/refs.go b/modelsdk/gen/customicons/refs.go new file mode 100644 index 00000000..480047ee --- /dev/null +++ b/modelsdk/gen/customicons/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customicons diff --git a/modelsdk/gen/customicons/types.go b/modelsdk/gen/customicons/types.go new file mode 100644 index 00000000..66ebb3d6 --- /dev/null +++ b/modelsdk/gen/customicons/types.go @@ -0,0 +1,257 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customicons + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// CustomIcon +// ──────────────────────────────────────────────────────── + +type CustomIcon struct { + element.Base + name *property.Primitive[string] + characterCode *property.Primitive[int32] + tags *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *CustomIcon) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CustomIcon) SetName(v string) { + o.name.Set(v) +} + +// CharacterCode returns the value of the characterCode property. +func (o *CustomIcon) CharacterCode() int32 { + return o.characterCode.Get() +} + +// SetCharacterCode sets the value of the characterCode property. +func (o *CustomIcon) SetCharacterCode(v int32) { + o.characterCode.Set(v) +} + +// Tags returns the value of the tags property. +func (o *CustomIcon) Tags() string { + return o.tags.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomIcon) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.characterCode.Init(raw) + o.tags.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CustomIconCollection +// ──────────────────────────────────────────────────────── + +type CustomIconCollection struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + collectionClass *property.Primitive[string] + prefix *property.Primitive[string] + fontData *property.Primitive[string] + icons *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *CustomIconCollection) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CustomIconCollection) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *CustomIconCollection) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *CustomIconCollection) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *CustomIconCollection) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *CustomIconCollection) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *CustomIconCollection) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *CustomIconCollection) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CollectionClass returns the value of the collectionClass property. +func (o *CustomIconCollection) CollectionClass() string { + return o.collectionClass.Get() +} + +// SetCollectionClass sets the value of the collectionClass property. +func (o *CustomIconCollection) SetCollectionClass(v string) { + o.collectionClass.Set(v) +} + +// Prefix returns the value of the prefix property. +func (o *CustomIconCollection) Prefix() string { + return o.prefix.Get() +} + +// SetPrefix sets the value of the prefix property. +func (o *CustomIconCollection) SetPrefix(v string) { + o.prefix.Set(v) +} + +// FontData returns the value of the fontData property. +func (o *CustomIconCollection) FontData() string { + return o.fontData.Get() +} + +// SetFontData sets the value of the fontData property. +func (o *CustomIconCollection) SetFontData(v string) { + o.fontData.Set(v) +} + +// IconsItems returns the value of the icons property. +func (o *CustomIconCollection) IconsItems() []element.Element { + return o.icons.Items() +} + +// AddIcons appends a child element to the icons list. +func (o *CustomIconCollection) AddIcons(v element.Element) { + o.icons.Append(v) +} + +// RemoveIcons removes the element at the given index from the icons list. +func (o *CustomIconCollection) RemoveIcons(index int) { + o.icons.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomIconCollection) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.collectionClass.Init(raw) + o.prefix.Init(raw) + o.fontData.Init(raw) + if children, err := codec.DecodeChildren(raw, "Icons"); err == nil { + for _, child := range children { + o.icons.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initCustomIcon creates a CustomIcon with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomIcon() *CustomIcon { + o := &CustomIcon{} + o.SetTypeName("CustomIcons$CustomIcon") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.characterCode = property.NewPrimitive[int32]("CharacterCode", property.DecodeInt32) + o.characterCode.Bind(&o.Base, 1) + o.tags = property.NewPrimitive[string]("Tags", property.DecodeString) + o.tags.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.characterCode, o.tags}) + return o +} + +// NewCustomIcon creates a new CustomIcon for user code. Marked dirty (bit 63 = new element). +func NewCustomIcon() *CustomIcon { + o := initCustomIcon() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomIconCollection creates a CustomIconCollection with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomIconCollection() *CustomIconCollection { + o := &CustomIconCollection{} + o.SetTypeName("CustomIcons$CustomIconCollection") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.collectionClass = property.NewPrimitive[string]("CollectionClass", property.DecodeString) + o.collectionClass.Bind(&o.Base, 4) + o.prefix = property.NewPrimitive[string]("Prefix", property.DecodeString) + o.prefix.Bind(&o.Base, 5) + o.fontData = property.NewPrimitive[string]("FontData", property.DecodeString) + o.fontData.Bind(&o.Base, 6) + o.icons = property.NewPartList[element.Element]("Icons") + o.icons.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.collectionClass, o.prefix, o.fontData, o.icons}) + return o +} + +// NewCustomIconCollection creates a new CustomIconCollection for user code. Marked dirty (bit 63 = new element). +func NewCustomIconCollection() *CustomIconCollection { + o := initCustomIconCollection() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("CustomIcons$CustomIcon", func() element.Element { + return initCustomIcon() + }) + codec.DefaultRegistry.Register("CustomIcons$CustomIconCollection", func() element.Element { + return initCustomIconCollection() + }) +} diff --git a/modelsdk/gen/customicons/version.go b/modelsdk/gen/customicons/version.go new file mode 100644 index 00000000..ced5c19a --- /dev/null +++ b/modelsdk/gen/customicons/version.go @@ -0,0 +1,26 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customicons + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "CustomIcons$CustomIcon": { + Properties: map[string]version.PropertyVersionInfo{ + "characterCode": {Public: true}, + "name": {Public: true}, + "tags": {Public: true}, + }, + }, + "CustomIcons$CustomIconCollection": { + Properties: map[string]version.PropertyVersionInfo{ + "collectionClass": {Introduced: "9.22.0", Public: true}, + "fontData": {Public: true}, + "icons": {Public: true}, + "prefix": {Introduced: "9.22.0", Public: true}, + }, + }, +} diff --git a/modelsdk/gen/customwidgets/enums.go b/modelsdk/gen/customwidgets/enums.go new file mode 100644 index 00000000..1a105779 --- /dev/null +++ b/modelsdk/gen/customwidgets/enums.go @@ -0,0 +1,128 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customwidgets + +// CustomWidgetAssociationType enumerates the possible values for the CustomWidgetAssociationType type. +type CustomWidgetAssociationType = string + +const ( + CustomWidgetAssociationTypeReference CustomWidgetAssociationType = "Reference" + CustomWidgetAssociationTypeReferenceSet CustomWidgetAssociationType = "ReferenceSet" +) + +// CustomWidgetAttributeType enumerates the possible values for the CustomWidgetAttributeType type. +type CustomWidgetAttributeType = string + +const ( + CustomWidgetAttributeTypeAutoNumber CustomWidgetAttributeType = "AutoNumber" + CustomWidgetAttributeTypeBinary CustomWidgetAttributeType = "Binary" + CustomWidgetAttributeTypeBoolean CustomWidgetAttributeType = "Boolean" + CustomWidgetAttributeTypeCurrency CustomWidgetAttributeType = "Currency" + CustomWidgetAttributeTypeDateTime CustomWidgetAttributeType = "DateTime" + CustomWidgetAttributeTypeEnum CustomWidgetAttributeType = "Enum" + CustomWidgetAttributeTypeFloat CustomWidgetAttributeType = "Float" + CustomWidgetAttributeTypeHashString CustomWidgetAttributeType = "HashString" + CustomWidgetAttributeTypeInteger CustomWidgetAttributeType = "Integer" + CustomWidgetAttributeTypeLong CustomWidgetAttributeType = "Long" + CustomWidgetAttributeTypeString CustomWidgetAttributeType = "String" + CustomWidgetAttributeTypeDecimal CustomWidgetAttributeType = "Decimal" +) + +// CustomWidgetSelectionType enumerates the possible values for the CustomWidgetSelectionType type. +type CustomWidgetSelectionType = string + +const ( + CustomWidgetSelectionTypeNone CustomWidgetSelectionType = "None" + CustomWidgetSelectionTypeSingle CustomWidgetSelectionType = "Single" + CustomWidgetSelectionTypeMulti CustomWidgetSelectionType = "Multi" +) + +// DefaultTypeEnum enumerates the possible values for the DefaultTypeEnum type. +type DefaultTypeEnum = string + +const ( + DefaultTypeEnumNone DefaultTypeEnum = "None" + DefaultTypeEnumCallMicroflow DefaultTypeEnum = "CallMicroflow" + DefaultTypeEnumCallNanoflow DefaultTypeEnum = "CallNanoflow" + DefaultTypeEnumOpenPage DefaultTypeEnum = "OpenPage" + DefaultTypeEnumDatabase DefaultTypeEnum = "Database" + DefaultTypeEnumMicroflow DefaultTypeEnum = "Microflow" + DefaultTypeEnumNanoflow DefaultTypeEnum = "Nanoflow" + DefaultTypeEnumAssociation DefaultTypeEnum = "Association" +) + +// IsPath enumerates the possible values for the IsPath type. +type IsPath = string + +const ( + IsPathNo IsPath = "No" + IsPathOptional IsPath = "Optional" + IsPathYes IsPath = "Yes" +) + +// PathType enumerates the possible values for the PathType type. +type PathType = string + +const ( + PathTypeNone PathType = "None" + PathTypeReference PathType = "Reference" + PathTypeReferenceSet PathType = "ReferenceSet" +) + +// SystemPropertyEnum enumerates the possible values for the SystemPropertyEnum type. +type SystemPropertyEnum = string + +const ( + SystemPropertyEnumLabel SystemPropertyEnum = "Label" + SystemPropertyEnumName SystemPropertyEnum = "Name" + SystemPropertyEnumTabIndex SystemPropertyEnum = "TabIndex" + SystemPropertyEnumEditability SystemPropertyEnum = "Editability" + SystemPropertyEnumVisibility SystemPropertyEnum = "Visibility" +) + +// WidgetReturnTypeEnum enumerates the possible values for the WidgetReturnTypeEnum type. +type WidgetReturnTypeEnum = string + +const ( + WidgetReturnTypeEnumNone WidgetReturnTypeEnum = "None" + WidgetReturnTypeEnumVoid WidgetReturnTypeEnum = "Void" + WidgetReturnTypeEnumBoolean WidgetReturnTypeEnum = "Boolean" + WidgetReturnTypeEnumInteger WidgetReturnTypeEnum = "Integer" + WidgetReturnTypeEnumFloat WidgetReturnTypeEnum = "Float" + WidgetReturnTypeEnumDateTime WidgetReturnTypeEnum = "DateTime" + WidgetReturnTypeEnumString WidgetReturnTypeEnum = "String" + WidgetReturnTypeEnumObject WidgetReturnTypeEnum = "Object" + WidgetReturnTypeEnumDecimal WidgetReturnTypeEnum = "Decimal" +) + +// WidgetValueTypeEnum enumerates the possible values for the WidgetValueTypeEnum type. +type WidgetValueTypeEnum = string + +const ( + WidgetValueTypeEnumAction WidgetValueTypeEnum = "Action" + WidgetValueTypeEnumAttribute WidgetValueTypeEnum = "Attribute" + WidgetValueTypeEnumAssociation WidgetValueTypeEnum = "Association" + WidgetValueTypeEnumBoolean WidgetValueTypeEnum = "Boolean" + WidgetValueTypeEnumDataSource WidgetValueTypeEnum = "DataSource" + WidgetValueTypeEnumEntity WidgetValueTypeEnum = "Entity" + WidgetValueTypeEnumEntityConstraint WidgetValueTypeEnum = "EntityConstraint" + WidgetValueTypeEnumEnumeration WidgetValueTypeEnum = "Enumeration" + WidgetValueTypeEnumExpression WidgetValueTypeEnum = "Expression" + WidgetValueTypeEnumFile WidgetValueTypeEnum = "File" + WidgetValueTypeEnumForm WidgetValueTypeEnum = "Form" + WidgetValueTypeEnumIcon WidgetValueTypeEnum = "Icon" + WidgetValueTypeEnumImage WidgetValueTypeEnum = "Image" + WidgetValueTypeEnumInteger WidgetValueTypeEnum = "Integer" + WidgetValueTypeEnumDecimal WidgetValueTypeEnum = "Decimal" + WidgetValueTypeEnumMicroflow WidgetValueTypeEnum = "Microflow" + WidgetValueTypeEnumNanoflow WidgetValueTypeEnum = "Nanoflow" + WidgetValueTypeEnumObject WidgetValueTypeEnum = "Object" + WidgetValueTypeEnumString WidgetValueTypeEnum = "String" + WidgetValueTypeEnumSelection WidgetValueTypeEnum = "Selection" + WidgetValueTypeEnumTranslatableString WidgetValueTypeEnum = "TranslatableString" + WidgetValueTypeEnumTextTemplate WidgetValueTypeEnum = "TextTemplate" + WidgetValueTypeEnumSystem WidgetValueTypeEnum = "System" + WidgetValueTypeEnumWidgets WidgetValueTypeEnum = "Widgets" +) diff --git a/modelsdk/gen/customwidgets/refs.go b/modelsdk/gen/customwidgets/refs.go new file mode 100644 index 00000000..5a3a012c --- /dev/null +++ b/modelsdk/gen/customwidgets/refs.go @@ -0,0 +1,23 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customwidgets + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("CustomWidgets$WidgetObject", []codec.RefMeta{ + {Prop: "TypePointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("CustomWidgets$WidgetProperty", []codec.RefMeta{ + {Prop: "TypePointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("CustomWidgets$WidgetValue", []codec.RefMeta{ + {Prop: "TypePointer", Kind: codec.RefById, Target: ""}, + {Prop: "Page", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "Nanoflow", Kind: codec.RefByName, Target: "Microflows$Nanoflow"}, + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + }) +} diff --git a/modelsdk/gen/customwidgets/types.go b/modelsdk/gen/customwidgets/types.go new file mode 100644 index 00000000..0d66b26c --- /dev/null +++ b/modelsdk/gen/customwidgets/types.go @@ -0,0 +1,2242 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customwidgets + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// CustomWidget +// ──────────────────────────────────────────────────────── + +type CustomWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + propType *property.Part[element.Element] + object *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + conditionalVisibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *CustomWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CustomWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *CustomWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *CustomWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *CustomWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *CustomWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *CustomWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *CustomWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *CustomWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *CustomWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// Type returns the value of the type property. +func (o *CustomWidget) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *CustomWidget) SetType(v element.Element) { + o.propType.Set(v) +} + +// Object returns the value of the object property. +func (o *CustomWidget) Object() element.Element { + return o.object.Get() +} + +// SetObject sets the value of the object property. +func (o *CustomWidget) SetObject(v element.Element) { + o.object.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *CustomWidget) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *CustomWidget) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *CustomWidget) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *CustomWidget) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *CustomWidget) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *CustomWidget) SetEditable(v string) { + o.editable.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *CustomWidget) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *CustomWidget) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Object"); err == nil { + o.object.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.editable.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// CustomWidgetDatabaseSource +// ──────────────────────────────────────────────────────── + +type CustomWidgetDatabaseSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] + databaseConstraints *property.PartList[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *CustomWidgetDatabaseSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *CustomWidgetDatabaseSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *CustomWidgetDatabaseSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *CustomWidgetDatabaseSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *CustomWidgetDatabaseSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *CustomWidgetDatabaseSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *CustomWidgetDatabaseSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *CustomWidgetDatabaseSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *CustomWidgetDatabaseSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *CustomWidgetDatabaseSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// DatabaseConstraintsItems returns the value of the databaseConstraints property. +func (o *CustomWidgetDatabaseSource) DatabaseConstraintsItems() []element.Element { + return o.databaseConstraints.Items() +} + +// AddDatabaseConstraints appends a child element to the databaseConstraints list. +func (o *CustomWidgetDatabaseSource) AddDatabaseConstraints(v element.Element) { + o.databaseConstraints.Append(v) +} + +// RemoveDatabaseConstraints removes the element at the given index from the databaseConstraints list. +func (o *CustomWidgetDatabaseSource) RemoveDatabaseConstraints(index int) { + o.databaseConstraints.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomWidgetDatabaseSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "DatabaseConstraints"); err == nil { + for _, child := range children { + o.databaseConstraints.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// CustomWidgetType +// ──────────────────────────────────────────────────────── + +type CustomWidgetType struct { + element.Base + widgetId *property.Primitive[string] + needsEntityContext *property.Primitive[bool] + pluginWidget *property.Primitive[bool] + name *property.Primitive[string] + description *property.Primitive[string] + studioProCategory *property.Primitive[string] + studioCategory *property.Primitive[string] + supportedPlatform *property.Enum[string] + phoneGapEnabled *property.Primitive[bool] + offlineCapable *property.Primitive[bool] + experimentalApi *property.Primitive[bool] + objectType *property.Part[element.Element] + labeled *property.Primitive[bool] + helpUrl *property.Primitive[string] +} + +// WidgetId returns the value of the widgetId property. +func (o *CustomWidgetType) WidgetId() string { + return o.widgetId.Get() +} + +// SetWidgetId sets the value of the widgetId property. +func (o *CustomWidgetType) SetWidgetId(v string) { + o.widgetId.Set(v) +} + +// NeedsEntityContext returns the value of the needsEntityContext property. +func (o *CustomWidgetType) NeedsEntityContext() bool { + return o.needsEntityContext.Get() +} + +// SetNeedsEntityContext sets the value of the needsEntityContext property. +func (o *CustomWidgetType) SetNeedsEntityContext(v bool) { + o.needsEntityContext.Set(v) +} + +// PluginWidget returns the value of the pluginWidget property. +func (o *CustomWidgetType) PluginWidget() bool { + return o.pluginWidget.Get() +} + +// SetPluginWidget sets the value of the pluginWidget property. +func (o *CustomWidgetType) SetPluginWidget(v bool) { + o.pluginWidget.Set(v) +} + +// Name returns the value of the name property. +func (o *CustomWidgetType) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CustomWidgetType) SetName(v string) { + o.name.Set(v) +} + +// Description returns the value of the description property. +func (o *CustomWidgetType) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *CustomWidgetType) SetDescription(v string) { + o.description.Set(v) +} + +// StudioProCategory returns the value of the studioProCategory property. +func (o *CustomWidgetType) StudioProCategory() string { + return o.studioProCategory.Get() +} + +// SetStudioProCategory sets the value of the studioProCategory property. +func (o *CustomWidgetType) SetStudioProCategory(v string) { + o.studioProCategory.Set(v) +} + +// StudioCategory returns the value of the studioCategory property. +func (o *CustomWidgetType) StudioCategory() string { + return o.studioCategory.Get() +} + +// SetStudioCategory sets the value of the studioCategory property. +func (o *CustomWidgetType) SetStudioCategory(v string) { + o.studioCategory.Set(v) +} + +// SupportedPlatform returns the value of the supportedPlatform property. +func (o *CustomWidgetType) SupportedPlatform() string { + return o.supportedPlatform.Get() +} + +// SetSupportedPlatform sets the value of the supportedPlatform property. +func (o *CustomWidgetType) SetSupportedPlatform(v string) { + o.supportedPlatform.Set(v) +} + +// PhoneGapEnabled returns the value of the phoneGapEnabled property. +func (o *CustomWidgetType) PhoneGapEnabled() bool { + return o.phoneGapEnabled.Get() +} + +// SetPhoneGapEnabled sets the value of the phoneGapEnabled property. +func (o *CustomWidgetType) SetPhoneGapEnabled(v bool) { + o.phoneGapEnabled.Set(v) +} + +// OfflineCapable returns the value of the offlineCapable property. +func (o *CustomWidgetType) OfflineCapable() bool { + return o.offlineCapable.Get() +} + +// SetOfflineCapable sets the value of the offlineCapable property. +func (o *CustomWidgetType) SetOfflineCapable(v bool) { + o.offlineCapable.Set(v) +} + +// ExperimentalApi returns the value of the experimentalApi property. +func (o *CustomWidgetType) ExperimentalApi() bool { + return o.experimentalApi.Get() +} + +// SetExperimentalApi sets the value of the experimentalApi property. +func (o *CustomWidgetType) SetExperimentalApi(v bool) { + o.experimentalApi.Set(v) +} + +// ObjectType returns the value of the objectType property. +func (o *CustomWidgetType) ObjectType() element.Element { + return o.objectType.Get() +} + +// SetObjectType sets the value of the objectType property. +func (o *CustomWidgetType) SetObjectType(v element.Element) { + o.objectType.Set(v) +} + +// Labeled returns the value of the labeled property. +func (o *CustomWidgetType) Labeled() bool { + return o.labeled.Get() +} + +// SetLabeled sets the value of the labeled property. +func (o *CustomWidgetType) SetLabeled(v bool) { + o.labeled.Set(v) +} + +// HelpUrl returns the value of the helpUrl property. +func (o *CustomWidgetType) HelpUrl() string { + return o.helpUrl.Get() +} + +// SetHelpUrl sets the value of the helpUrl property. +func (o *CustomWidgetType) SetHelpUrl(v string) { + o.helpUrl.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomWidgetType) InitFromRaw(raw bson.Raw) { + o.widgetId.Init(raw) + o.needsEntityContext.Init(raw) + o.pluginWidget.Init(raw) + o.name.Init(raw) + o.description.Init(raw) + o.studioProCategory.Init(raw) + o.studioCategory.Init(raw) + if val, err := raw.LookupErr("SupportedPlatform"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.supportedPlatform.SetFromDecode(s) + } + } + o.phoneGapEnabled.Init(raw) + o.offlineCapable.Init(raw) + o.experimentalApi.Init(raw) + if child, err := codec.DecodeChild(raw, "ObjectType"); err == nil { + o.objectType.SetFromDecode(child) + } + o.labeled.Init(raw) + o.helpUrl.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CustomWidgetXPathSource +// ──────────────────────────────────────────────────────── + +type CustomWidgetXPathSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] + xPathConstraint *property.Primitive[string] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *CustomWidgetXPathSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *CustomWidgetXPathSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *CustomWidgetXPathSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *CustomWidgetXPathSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *CustomWidgetXPathSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *CustomWidgetXPathSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *CustomWidgetXPathSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *CustomWidgetXPathSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *CustomWidgetXPathSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *CustomWidgetXPathSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *CustomWidgetXPathSource) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *CustomWidgetXPathSource) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomWidgetXPathSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + o.xPathConstraint.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WidgetActionVariable +// ──────────────────────────────────────────────────────── + +type WidgetActionVariable struct { + element.Base + key *property.Primitive[string] + propType *property.Enum[string] + caption *property.Primitive[string] +} + +// Key returns the value of the key property. +func (o *WidgetActionVariable) Key() string { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *WidgetActionVariable) SetKey(v string) { + o.key.Set(v) +} + +// Type returns the value of the type property. +func (o *WidgetActionVariable) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *WidgetActionVariable) SetType(v string) { + o.propType.Set(v) +} + +// Caption returns the value of the caption property. +func (o *WidgetActionVariable) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *WidgetActionVariable) SetCaption(v string) { + o.caption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetActionVariable) InitFromRaw(raw bson.Raw) { + o.key.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(s) + } + } + o.caption.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WidgetEnumerationValue +// ──────────────────────────────────────────────────────── + +type WidgetEnumerationValue struct { + element.Base + key *property.Primitive[string] + caption *property.Primitive[string] +} + +// Key returns the value of the key property. +func (o *WidgetEnumerationValue) Key() string { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *WidgetEnumerationValue) SetKey(v string) { + o.key.Set(v) +} + +// Caption returns the value of the caption property. +func (o *WidgetEnumerationValue) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *WidgetEnumerationValue) SetCaption(v string) { + o.caption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetEnumerationValue) InitFromRaw(raw bson.Raw) { + o.key.Init(raw) + o.caption.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WidgetObject +// ──────────────────────────────────────────────────────── + +type WidgetObject struct { + element.Base + propType *property.ByIdRef[element.Element] + properties *property.PartList[element.Element] + labelTemplate *property.Part[element.Element] +} + +// TypeRefID returns the value of the type property. +func (o *WidgetObject) TypeRefID() element.ID { + return o.propType.RefID() +} + +// SetTypeID sets the value of the type property. +func (o *WidgetObject) SetTypeID(v element.ID) { + o.propType.SetID(v) +} + +// PropertiesItems returns the value of the properties property. +func (o *WidgetObject) PropertiesItems() []element.Element { + return o.properties.Items() +} + +// AddProperties appends a child element to the properties list. +func (o *WidgetObject) AddProperties(v element.Element) { + o.properties.Append(v) +} + +// RemoveProperties removes the element at the given index from the properties list. +func (o *WidgetObject) RemoveProperties(index int) { + o.properties.Remove(index) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *WidgetObject) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *WidgetObject) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetObject) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("TypePointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.propType.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + if children, err := codec.DecodeChildren(raw, "Properties"); err == nil { + for _, child := range children { + o.properties.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// WidgetObjectType +// ──────────────────────────────────────────────────────── + +type WidgetObjectType struct { + element.Base + propertyTypes *property.PartList[element.Element] +} + +// PropertyTypesItems returns the value of the propertyTypes property. +func (o *WidgetObjectType) PropertyTypesItems() []element.Element { + return o.propertyTypes.Items() +} + +// AddPropertyTypes appends a child element to the propertyTypes list. +func (o *WidgetObjectType) AddPropertyTypes(v element.Element) { + o.propertyTypes.Append(v) +} + +// RemovePropertyTypes removes the element at the given index from the propertyTypes list. +func (o *WidgetObjectType) RemovePropertyTypes(index int) { + o.propertyTypes.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetObjectType) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "PropertyTypes"); err == nil { + for _, child := range children { + o.propertyTypes.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// WidgetProperty +// ──────────────────────────────────────────────────────── + +type WidgetProperty struct { + element.Base + propType *property.ByIdRef[element.Element] + value *property.Part[element.Element] +} + +// TypeRefID returns the value of the type property. +func (o *WidgetProperty) TypeRefID() element.ID { + return o.propType.RefID() +} + +// SetTypeID sets the value of the type property. +func (o *WidgetProperty) SetTypeID(v element.ID) { + o.propType.SetID(v) +} + +// Value returns the value of the value property. +func (o *WidgetProperty) Value() element.Element { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *WidgetProperty) SetValue(v element.Element) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetProperty) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("TypePointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.propType.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + if child, err := codec.DecodeChild(raw, "Value"); err == nil { + o.value.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// WidgetPropertyType +// ──────────────────────────────────────────────────────── + +type WidgetPropertyType struct { + element.Base + key *property.Primitive[string] + category *property.Primitive[string] + caption *property.Primitive[string] + description *property.Primitive[string] + isDefault *property.Primitive[bool] + valueType *property.Part[element.Element] +} + +// Key returns the value of the key property. +func (o *WidgetPropertyType) Key() string { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *WidgetPropertyType) SetKey(v string) { + o.key.Set(v) +} + +// Category returns the value of the category property. +func (o *WidgetPropertyType) Category() string { + return o.category.Get() +} + +// SetCategory sets the value of the category property. +func (o *WidgetPropertyType) SetCategory(v string) { + o.category.Set(v) +} + +// Caption returns the value of the caption property. +func (o *WidgetPropertyType) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *WidgetPropertyType) SetCaption(v string) { + o.caption.Set(v) +} + +// Description returns the value of the description property. +func (o *WidgetPropertyType) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *WidgetPropertyType) SetDescription(v string) { + o.description.Set(v) +} + +// IsDefault returns the value of the isDefault property. +func (o *WidgetPropertyType) IsDefault() bool { + return o.isDefault.Get() +} + +// SetIsDefault sets the value of the isDefault property. +func (o *WidgetPropertyType) SetIsDefault(v bool) { + o.isDefault.Set(v) +} + +// ValueType returns the value of the valueType property. +func (o *WidgetPropertyType) ValueType() element.Element { + return o.valueType.Get() +} + +// SetValueType sets the value of the valueType property. +func (o *WidgetPropertyType) SetValueType(v element.Element) { + o.valueType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetPropertyType) InitFromRaw(raw bson.Raw) { + o.key.Init(raw) + o.category.Init(raw) + o.caption.Init(raw) + o.description.Init(raw) + o.isDefault.Init(raw) + if child, err := codec.DecodeChild(raw, "ValueType"); err == nil { + o.valueType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// WidgetReturnType +// ──────────────────────────────────────────────────────── + +type WidgetReturnType struct { + element.Base + propType *property.Enum[string] + isList *property.Primitive[bool] + entityProperty *property.Primitive[string] + assignableTo *property.Primitive[string] +} + +// Type returns the value of the type property. +func (o *WidgetReturnType) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *WidgetReturnType) SetType(v string) { + o.propType.Set(v) +} + +// IsList returns the value of the isList property. +func (o *WidgetReturnType) IsList() bool { + return o.isList.Get() +} + +// SetIsList sets the value of the isList property. +func (o *WidgetReturnType) SetIsList(v bool) { + o.isList.Set(v) +} + +// EntityProperty returns the value of the entityProperty property. +func (o *WidgetReturnType) EntityProperty() string { + return o.entityProperty.Get() +} + +// SetEntityProperty sets the value of the entityProperty property. +func (o *WidgetReturnType) SetEntityProperty(v string) { + o.entityProperty.Set(v) +} + +// AssignableTo returns the value of the assignableTo property. +func (o *WidgetReturnType) AssignableTo() string { + return o.assignableTo.Get() +} + +// SetAssignableTo sets the value of the assignableTo property. +func (o *WidgetReturnType) SetAssignableTo(v string) { + o.assignableTo.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetReturnType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(s) + } + } + o.isList.Init(raw) + o.entityProperty.Init(raw) + o.assignableTo.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WidgetTranslation +// ──────────────────────────────────────────────────────── + +type WidgetTranslation struct { + element.Base + languageCode *property.Primitive[string] + text *property.Primitive[string] +} + +// LanguageCode returns the value of the languageCode property. +func (o *WidgetTranslation) LanguageCode() string { + return o.languageCode.Get() +} + +// SetLanguageCode sets the value of the languageCode property. +func (o *WidgetTranslation) SetLanguageCode(v string) { + o.languageCode.Set(v) +} + +// Text returns the value of the text property. +func (o *WidgetTranslation) Text() string { + return o.text.Get() +} + +// SetText sets the value of the text property. +func (o *WidgetTranslation) SetText(v string) { + o.text.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetTranslation) InitFromRaw(raw bson.Raw) { + o.languageCode.Init(raw) + o.text.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WidgetValue +// ──────────────────────────────────────────────────────── + +type WidgetValue struct { + element.Base + propType *property.ByIdRef[element.Element] + primitiveValue *property.Primitive[string] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + page *property.ByNameRef[element.Element] + microflow *property.ByNameRef[element.Element] + nanoflow *property.ByNameRef[element.Element] + icon *property.Part[element.Element] + image *property.ByNameRef[element.Element] + translatableValue *property.Part[element.Element] + textTemplate *property.Part[element.Element] + xPathConstraint *property.Primitive[string] + objects *property.PartList[element.Element] + action *property.Part[element.Element] + expression *property.Primitive[string] + widgets *property.PartList[element.Element] + dataSource *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + selection *property.Enum[string] +} + +// TypeRefID returns the value of the type property. +func (o *WidgetValue) TypeRefID() element.ID { + return o.propType.RefID() +} + +// SetTypeID sets the value of the type property. +func (o *WidgetValue) SetTypeID(v element.ID) { + o.propType.SetID(v) +} + +// PrimitiveValue returns the value of the primitiveValue property. +func (o *WidgetValue) PrimitiveValue() string { + return o.primitiveValue.Get() +} + +// SetPrimitiveValue sets the value of the primitiveValue property. +func (o *WidgetValue) SetPrimitiveValue(v string) { + o.primitiveValue.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *WidgetValue) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *WidgetValue) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *WidgetValue) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *WidgetValue) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *WidgetValue) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *WidgetValue) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *WidgetValue) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *WidgetValue) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// PageQualifiedName returns the value of the page property. +func (o *WidgetValue) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *WidgetValue) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *WidgetValue) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *WidgetValue) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// NanoflowQualifiedName returns the value of the nanoflow property. +func (o *WidgetValue) NanoflowQualifiedName() string { + return o.nanoflow.QualifiedName() +} + +// SetNanoflowQualifiedName sets the value of the nanoflow property. +func (o *WidgetValue) SetNanoflowQualifiedName(v string) { + o.nanoflow.SetQualifiedName(v) +} + +// Icon returns the value of the icon property. +func (o *WidgetValue) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *WidgetValue) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// ImageQualifiedName returns the value of the image property. +func (o *WidgetValue) ImageQualifiedName() string { + return o.image.QualifiedName() +} + +// SetImageQualifiedName sets the value of the image property. +func (o *WidgetValue) SetImageQualifiedName(v string) { + o.image.SetQualifiedName(v) +} + +// TranslatableValue returns the value of the translatableValue property. +func (o *WidgetValue) TranslatableValue() element.Element { + return o.translatableValue.Get() +} + +// SetTranslatableValue sets the value of the translatableValue property. +func (o *WidgetValue) SetTranslatableValue(v element.Element) { + o.translatableValue.Set(v) +} + +// TextTemplate returns the value of the textTemplate property. +func (o *WidgetValue) TextTemplate() element.Element { + return o.textTemplate.Get() +} + +// SetTextTemplate sets the value of the textTemplate property. +func (o *WidgetValue) SetTextTemplate(v element.Element) { + o.textTemplate.Set(v) +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *WidgetValue) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *WidgetValue) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// ObjectsItems returns the value of the objects property. +func (o *WidgetValue) ObjectsItems() []element.Element { + return o.objects.Items() +} + +// AddObjects appends a child element to the objects list. +func (o *WidgetValue) AddObjects(v element.Element) { + o.objects.Append(v) +} + +// RemoveObjects removes the element at the given index from the objects list. +func (o *WidgetValue) RemoveObjects(index int) { + o.objects.Remove(index) +} + +// Action returns the value of the action property. +func (o *WidgetValue) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *WidgetValue) SetAction(v element.Element) { + o.action.Set(v) +} + +// Expression returns the value of the expression property. +func (o *WidgetValue) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *WidgetValue) SetExpression(v string) { + o.expression.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *WidgetValue) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *WidgetValue) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *WidgetValue) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// DataSource returns the value of the dataSource property. +func (o *WidgetValue) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *WidgetValue) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *WidgetValue) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *WidgetValue) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// Selection returns the value of the selection property. +func (o *WidgetValue) Selection() string { + return o.selection.Get() +} + +// SetSelection sets the value of the selection property. +func (o *WidgetValue) SetSelection(v string) { + o.selection.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("TypePointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.propType.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.primitiveValue.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("Page"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.page.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Nanoflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.nanoflow.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("Image"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.image.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "TranslatableValue"); err == nil { + o.translatableValue.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TextTemplate"); err == nil { + o.textTemplate.SetFromDecode(child) + } + o.xPathConstraint.Init(raw) + if children, err := codec.DecodeChildren(raw, "Objects"); err == nil { + for _, child := range children { + o.objects.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } + o.expression.Init(raw) + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if val, err := raw.LookupErr("Selection"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.selection.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// WidgetValueType +// ──────────────────────────────────────────────────────── + +type WidgetValueType struct { + element.Base + propType *property.Enum[string] + isList *property.Primitive[bool] + isLinked *property.Primitive[bool] + isMetaData *property.Primitive[bool] + entityProperty *property.Primitive[string] + allowNonPersistableEntities *property.Primitive[bool] + isPath *property.Enum[string] + pathType *property.Enum[string] + parameterIsList *property.Primitive[bool] + multiline *property.Primitive[bool] + defaultValue *property.Primitive[string] + required *property.Primitive[bool] + onChangeProperty *property.Primitive[string] + dataSourceProperty *property.Primitive[string] + universeDataSourceProperty *property.Primitive[string] + selectableObjectsProperty *property.Primitive[string] + attributeTypes *property.EnumList[string] + associationTypes *property.EnumList[string] + selectionTypes *property.EnumList[string] + enumerationValues *property.PartList[element.Element] + actionVariables *property.PartList[element.Element] + objectType *property.Part[element.Element] + returnType *property.Part[element.Element] + translations *property.PartList[element.Element] + setLabel *property.Primitive[bool] + defaultType *property.Enum[string] + allowUpload *property.Primitive[bool] +} + +// Type returns the value of the type property. +func (o *WidgetValueType) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *WidgetValueType) SetType(v string) { + o.propType.Set(v) +} + +// IsList returns the value of the isList property. +func (o *WidgetValueType) IsList() bool { + return o.isList.Get() +} + +// SetIsList sets the value of the isList property. +func (o *WidgetValueType) SetIsList(v bool) { + o.isList.Set(v) +} + +// IsLinked returns the value of the isLinked property. +func (o *WidgetValueType) IsLinked() bool { + return o.isLinked.Get() +} + +// SetIsLinked sets the value of the isLinked property. +func (o *WidgetValueType) SetIsLinked(v bool) { + o.isLinked.Set(v) +} + +// IsMetaData returns the value of the isMetaData property. +func (o *WidgetValueType) IsMetaData() bool { + return o.isMetaData.Get() +} + +// SetIsMetaData sets the value of the isMetaData property. +func (o *WidgetValueType) SetIsMetaData(v bool) { + o.isMetaData.Set(v) +} + +// EntityProperty returns the value of the entityProperty property. +func (o *WidgetValueType) EntityProperty() string { + return o.entityProperty.Get() +} + +// SetEntityProperty sets the value of the entityProperty property. +func (o *WidgetValueType) SetEntityProperty(v string) { + o.entityProperty.Set(v) +} + +// AllowNonPersistableEntities returns the value of the allowNonPersistableEntities property. +func (o *WidgetValueType) AllowNonPersistableEntities() bool { + return o.allowNonPersistableEntities.Get() +} + +// SetAllowNonPersistableEntities sets the value of the allowNonPersistableEntities property. +func (o *WidgetValueType) SetAllowNonPersistableEntities(v bool) { + o.allowNonPersistableEntities.Set(v) +} + +// IsPath returns the value of the isPath property. +func (o *WidgetValueType) IsPath() string { + return o.isPath.Get() +} + +// SetIsPath sets the value of the isPath property. +func (o *WidgetValueType) SetIsPath(v string) { + o.isPath.Set(v) +} + +// PathType returns the value of the pathType property. +func (o *WidgetValueType) PathType() string { + return o.pathType.Get() +} + +// SetPathType sets the value of the pathType property. +func (o *WidgetValueType) SetPathType(v string) { + o.pathType.Set(v) +} + +// ParameterIsList returns the value of the parameterIsList property. +func (o *WidgetValueType) ParameterIsList() bool { + return o.parameterIsList.Get() +} + +// SetParameterIsList sets the value of the parameterIsList property. +func (o *WidgetValueType) SetParameterIsList(v bool) { + o.parameterIsList.Set(v) +} + +// Multiline returns the value of the multiline property. +func (o *WidgetValueType) Multiline() bool { + return o.multiline.Get() +} + +// SetMultiline sets the value of the multiline property. +func (o *WidgetValueType) SetMultiline(v bool) { + o.multiline.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *WidgetValueType) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *WidgetValueType) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// Required returns the value of the required property. +func (o *WidgetValueType) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *WidgetValueType) SetRequired(v bool) { + o.required.Set(v) +} + +// OnChangeProperty returns the value of the onChangeProperty property. +func (o *WidgetValueType) OnChangeProperty() string { + return o.onChangeProperty.Get() +} + +// SetOnChangeProperty sets the value of the onChangeProperty property. +func (o *WidgetValueType) SetOnChangeProperty(v string) { + o.onChangeProperty.Set(v) +} + +// DataSourceProperty returns the value of the dataSourceProperty property. +func (o *WidgetValueType) DataSourceProperty() string { + return o.dataSourceProperty.Get() +} + +// SetDataSourceProperty sets the value of the dataSourceProperty property. +func (o *WidgetValueType) SetDataSourceProperty(v string) { + o.dataSourceProperty.Set(v) +} + +// UniverseDataSourceProperty returns the value of the universeDataSourceProperty property. +func (o *WidgetValueType) UniverseDataSourceProperty() string { + return o.universeDataSourceProperty.Get() +} + +// SetUniverseDataSourceProperty sets the value of the universeDataSourceProperty property. +func (o *WidgetValueType) SetUniverseDataSourceProperty(v string) { + o.universeDataSourceProperty.Set(v) +} + +// SelectableObjectsProperty returns the value of the selectableObjectsProperty property. +func (o *WidgetValueType) SelectableObjectsProperty() string { + return o.selectableObjectsProperty.Get() +} + +// SetSelectableObjectsProperty sets the value of the selectableObjectsProperty property. +func (o *WidgetValueType) SetSelectableObjectsProperty(v string) { + o.selectableObjectsProperty.Set(v) +} + +// AttributeTypesItems returns the value of the attributeTypes property. +func (o *WidgetValueType) AttributeTypesItems() []string { + return o.attributeTypes.Items() +} + +// AddAttributeTypes appends a child element to the attributeTypes list. +func (o *WidgetValueType) AddAttributeTypes(v string) { + o.attributeTypes.Append(v) +} + +// AssociationTypesItems returns the value of the associationTypes property. +func (o *WidgetValueType) AssociationTypesItems() []string { + return o.associationTypes.Items() +} + +// AddAssociationTypes appends a child element to the associationTypes list. +func (o *WidgetValueType) AddAssociationTypes(v string) { + o.associationTypes.Append(v) +} + +// SelectionTypesItems returns the value of the selectionTypes property. +func (o *WidgetValueType) SelectionTypesItems() []string { + return o.selectionTypes.Items() +} + +// AddSelectionTypes appends a child element to the selectionTypes list. +func (o *WidgetValueType) AddSelectionTypes(v string) { + o.selectionTypes.Append(v) +} + +// EnumerationValuesItems returns the value of the enumerationValues property. +func (o *WidgetValueType) EnumerationValuesItems() []element.Element { + return o.enumerationValues.Items() +} + +// AddEnumerationValues appends a child element to the enumerationValues list. +func (o *WidgetValueType) AddEnumerationValues(v element.Element) { + o.enumerationValues.Append(v) +} + +// RemoveEnumerationValues removes the element at the given index from the enumerationValues list. +func (o *WidgetValueType) RemoveEnumerationValues(index int) { + o.enumerationValues.Remove(index) +} + +// ActionVariablesItems returns the value of the actionVariables property. +func (o *WidgetValueType) ActionVariablesItems() []element.Element { + return o.actionVariables.Items() +} + +// AddActionVariables appends a child element to the actionVariables list. +func (o *WidgetValueType) AddActionVariables(v element.Element) { + o.actionVariables.Append(v) +} + +// RemoveActionVariables removes the element at the given index from the actionVariables list. +func (o *WidgetValueType) RemoveActionVariables(index int) { + o.actionVariables.Remove(index) +} + +// ObjectType returns the value of the objectType property. +func (o *WidgetValueType) ObjectType() element.Element { + return o.objectType.Get() +} + +// SetObjectType sets the value of the objectType property. +func (o *WidgetValueType) SetObjectType(v element.Element) { + o.objectType.Set(v) +} + +// ReturnType returns the value of the returnType property. +func (o *WidgetValueType) ReturnType() element.Element { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *WidgetValueType) SetReturnType(v element.Element) { + o.returnType.Set(v) +} + +// TranslationsItems returns the value of the translations property. +func (o *WidgetValueType) TranslationsItems() []element.Element { + return o.translations.Items() +} + +// AddTranslations appends a child element to the translations list. +func (o *WidgetValueType) AddTranslations(v element.Element) { + o.translations.Append(v) +} + +// RemoveTranslations removes the element at the given index from the translations list. +func (o *WidgetValueType) RemoveTranslations(index int) { + o.translations.Remove(index) +} + +// SetLabel returns the value of the setLabel property. +func (o *WidgetValueType) SetLabel() bool { + return o.setLabel.Get() +} + +// SetSetLabel sets the value of the setLabel property. +func (o *WidgetValueType) SetSetLabel(v bool) { + o.setLabel.Set(v) +} + +// DefaultType returns the value of the defaultType property. +func (o *WidgetValueType) DefaultType() string { + return o.defaultType.Get() +} + +// SetDefaultType sets the value of the defaultType property. +func (o *WidgetValueType) SetDefaultType(v string) { + o.defaultType.Set(v) +} + +// AllowUpload returns the value of the allowUpload property. +func (o *WidgetValueType) AllowUpload() bool { + return o.allowUpload.Get() +} + +// SetAllowUpload sets the value of the allowUpload property. +func (o *WidgetValueType) SetAllowUpload(v bool) { + o.allowUpload.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetValueType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(s) + } + } + o.isList.Init(raw) + o.isLinked.Init(raw) + o.isMetaData.Init(raw) + o.entityProperty.Init(raw) + o.allowNonPersistableEntities.Init(raw) + if val, err := raw.LookupErr("IsPath"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.isPath.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PathType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.pathType.SetFromDecode(s) + } + } + o.parameterIsList.Init(raw) + o.multiline.Init(raw) + o.defaultValue.Init(raw) + o.required.Init(raw) + o.onChangeProperty.Init(raw) + o.dataSourceProperty.Init(raw) + o.universeDataSourceProperty.Init(raw) + o.selectableObjectsProperty.Init(raw) + if val, err := raw.LookupErr("AttributeTypes"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + items := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { + items = append(items, s) + } + } + o.attributeTypes.SetFromDecode(items) + } + } + if val, err := raw.LookupErr("AssociationTypes"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + items := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { + items = append(items, s) + } + } + o.associationTypes.SetFromDecode(items) + } + } + if val, err := raw.LookupErr("SelectionTypes"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + items := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { + items = append(items, s) + } + } + o.selectionTypes.SetFromDecode(items) + } + } + if children, err := codec.DecodeChildren(raw, "EnumerationValues"); err == nil { + for _, child := range children { + o.enumerationValues.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "ActionVariables"); err == nil { + for _, child := range children { + o.actionVariables.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ObjectType"); err == nil { + o.objectType.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ReturnType"); err == nil { + o.returnType.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Translations"); err == nil { + for _, child := range children { + o.translations.AppendFromDecode(child) + } + } + o.setLabel.Init(raw) + if val, err := raw.LookupErr("DefaultType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.defaultType.SetFromDecode(s) + } + } + o.allowUpload.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initCustomWidget creates a CustomWidget with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomWidget() *CustomWidget { + o := &CustomWidget{} + o.SetTypeName("CustomWidgets$CustomWidget") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 5) + o.object = property.NewPart[element.Element]("Object") + o.object.Bind(&o.Base, 6) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 7) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 8) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 9) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.propType, o.object, o.labelTemplate, o.conditionalEditabilitySettings, o.editable, o.conditionalVisibilitySettings}) + return o +} + +// NewCustomWidget creates a new CustomWidget for user code. Marked dirty (bit 63 = new element). +func NewCustomWidget() *CustomWidget { + o := initCustomWidget() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomWidgetDatabaseSource creates a CustomWidgetDatabaseSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomWidgetDatabaseSource() *CustomWidgetDatabaseSource { + o := &CustomWidgetDatabaseSource{} + o.SetTypeName("CustomWidgets$CustomWidgetDatabaseSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 4) + o.databaseConstraints = property.NewPartList[element.Element]("DatabaseConstraints") + o.databaseConstraints.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, o.sortBar, o.databaseConstraints}) + return o +} + +// NewCustomWidgetDatabaseSource creates a new CustomWidgetDatabaseSource for user code. Marked dirty (bit 63 = new element). +func NewCustomWidgetDatabaseSource() *CustomWidgetDatabaseSource { + o := initCustomWidgetDatabaseSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomWidgetType creates a CustomWidgetType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomWidgetType() *CustomWidgetType { + o := &CustomWidgetType{} + o.SetTypeName("CustomWidgets$CustomWidgetType") + o.widgetId = property.NewPrimitive[string]("WidgetId", property.DecodeString) + o.widgetId.Bind(&o.Base, 0) + o.needsEntityContext = property.NewPrimitive[bool]("NeedsEntityContext", property.DecodeBool) + o.needsEntityContext.Bind(&o.Base, 1) + o.pluginWidget = property.NewPrimitive[bool]("PluginWidget", property.DecodeBool) + o.pluginWidget.Bind(&o.Base, 2) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 3) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 4) + o.studioProCategory = property.NewPrimitive[string]("StudioProCategory", property.DecodeString) + o.studioProCategory.Bind(&o.Base, 5) + o.studioCategory = property.NewPrimitive[string]("StudioCategory", property.DecodeString) + o.studioCategory.Bind(&o.Base, 6) + o.supportedPlatform = property.NewEnum[string]("SupportedPlatform") + o.supportedPlatform.Bind(&o.Base, 7) + o.phoneGapEnabled = property.NewPrimitive[bool]("PhoneGapEnabled", property.DecodeBool) + o.phoneGapEnabled.Bind(&o.Base, 8) + o.offlineCapable = property.NewPrimitive[bool]("OfflineCapable", property.DecodeBool) + o.offlineCapable.Bind(&o.Base, 9) + o.experimentalApi = property.NewPrimitive[bool]("ExperimentalApi", property.DecodeBool) + o.experimentalApi.Bind(&o.Base, 10) + o.objectType = property.NewPart[element.Element]("ObjectType") + o.objectType.Bind(&o.Base, 11) + o.labeled = property.NewPrimitive[bool]("Labeled", property.DecodeBool) + o.labeled.Bind(&o.Base, 12) + o.helpUrl = property.NewPrimitive[string]("HelpUrl", property.DecodeString) + o.helpUrl.Bind(&o.Base, 13) + o.SetProperties([]element.Property{o.widgetId, o.needsEntityContext, o.pluginWidget, o.name, o.description, o.studioProCategory, o.studioCategory, o.supportedPlatform, o.phoneGapEnabled, o.offlineCapable, o.experimentalApi, o.objectType, o.labeled, o.helpUrl}) + return o +} + +// NewCustomWidgetType creates a new CustomWidgetType for user code. Marked dirty (bit 63 = new element). +func NewCustomWidgetType() *CustomWidgetType { + o := initCustomWidgetType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomWidgetXPathSource creates a CustomWidgetXPathSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomWidgetXPathSource() *CustomWidgetXPathSource { + o := &CustomWidgetXPathSource{} + o.SetTypeName("CustomWidgets$CustomWidgetXPathSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 4) + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, o.sortBar, o.xPathConstraint}) + return o +} + +// NewCustomWidgetXPathSource creates a new CustomWidgetXPathSource for user code. Marked dirty (bit 63 = new element). +func NewCustomWidgetXPathSource() *CustomWidgetXPathSource { + o := initCustomWidgetXPathSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetActionVariable creates a WidgetActionVariable with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetActionVariable() *WidgetActionVariable { + o := &WidgetActionVariable{} + o.SetTypeName("CustomWidgets$WidgetActionVariable") + o.key = property.NewPrimitive[string]("Key", property.DecodeString) + o.key.Bind(&o.Base, 0) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.key, o.propType, o.caption}) + return o +} + +// NewWidgetActionVariable creates a new WidgetActionVariable for user code. Marked dirty (bit 63 = new element). +func NewWidgetActionVariable() *WidgetActionVariable { + o := initWidgetActionVariable() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetEnumerationValue creates a WidgetEnumerationValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetEnumerationValue() *WidgetEnumerationValue { + o := &WidgetEnumerationValue{} + o.SetTypeName("CustomWidgets$WidgetEnumerationValue") + o.key = property.NewPrimitive[string]("Key", property.DecodeString) + o.key.Bind(&o.Base, 0) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.key, o.caption}) + return o +} + +// NewWidgetEnumerationValue creates a new WidgetEnumerationValue for user code. Marked dirty (bit 63 = new element). +func NewWidgetEnumerationValue() *WidgetEnumerationValue { + o := initWidgetEnumerationValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetObject creates a WidgetObject with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetObject() *WidgetObject { + o := &WidgetObject{} + o.SetTypeName("CustomWidgets$WidgetObject") + o.propType = property.NewByIdRef[element.Element]("TypePointer") + o.propType.Bind(&o.Base, 0) + o.properties = property.NewPartList[element.Element]("Properties") + o.properties.Bind(&o.Base, 1) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.propType, o.properties, o.labelTemplate}) + return o +} + +// NewWidgetObject creates a new WidgetObject for user code. Marked dirty (bit 63 = new element). +func NewWidgetObject() *WidgetObject { + o := initWidgetObject() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetObjectType creates a WidgetObjectType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetObjectType() *WidgetObjectType { + o := &WidgetObjectType{} + o.SetTypeName("CustomWidgets$WidgetObjectType") + o.propertyTypes = property.NewPartList[element.Element]("PropertyTypes") + o.propertyTypes.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.propertyTypes}) + return o +} + +// NewWidgetObjectType creates a new WidgetObjectType for user code. Marked dirty (bit 63 = new element). +func NewWidgetObjectType() *WidgetObjectType { + o := initWidgetObjectType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetProperty creates a WidgetProperty with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetProperty() *WidgetProperty { + o := &WidgetProperty{} + o.SetTypeName("CustomWidgets$WidgetProperty") + o.propType = property.NewByIdRef[element.Element]("TypePointer") + o.propType.Bind(&o.Base, 0) + o.value = property.NewPart[element.Element]("Value") + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.propType, o.value}) + return o +} + +// NewWidgetProperty creates a new WidgetProperty for user code. Marked dirty (bit 63 = new element). +func NewWidgetProperty() *WidgetProperty { + o := initWidgetProperty() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetPropertyType creates a WidgetPropertyType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetPropertyType() *WidgetPropertyType { + o := &WidgetPropertyType{} + o.SetTypeName("CustomWidgets$WidgetPropertyType") + o.key = property.NewPrimitive[string]("Key", property.DecodeString) + o.key.Bind(&o.Base, 0) + o.category = property.NewPrimitive[string]("Category", property.DecodeString) + o.category.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 3) + o.isDefault = property.NewPrimitive[bool]("IsDefault", property.DecodeBool) + o.isDefault.Bind(&o.Base, 4) + o.valueType = property.NewPart[element.Element]("ValueType") + o.valueType.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.key, o.category, o.caption, o.description, o.isDefault, o.valueType}) + return o +} + +// NewWidgetPropertyType creates a new WidgetPropertyType for user code. Marked dirty (bit 63 = new element). +func NewWidgetPropertyType() *WidgetPropertyType { + o := initWidgetPropertyType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetReturnType creates a WidgetReturnType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetReturnType() *WidgetReturnType { + o := &WidgetReturnType{} + o.SetTypeName("CustomWidgets$WidgetReturnType") + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 0) + o.isList = property.NewPrimitive[bool]("IsList", property.DecodeBool) + o.isList.Bind(&o.Base, 1) + o.entityProperty = property.NewPrimitive[string]("EntityProperty", property.DecodeString) + o.entityProperty.Bind(&o.Base, 2) + o.assignableTo = property.NewPrimitive[string]("AssignableTo", property.DecodeString) + o.assignableTo.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.propType, o.isList, o.entityProperty, o.assignableTo}) + return o +} + +// NewWidgetReturnType creates a new WidgetReturnType for user code. Marked dirty (bit 63 = new element). +func NewWidgetReturnType() *WidgetReturnType { + o := initWidgetReturnType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetTranslation creates a WidgetTranslation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetTranslation() *WidgetTranslation { + o := &WidgetTranslation{} + o.SetTypeName("CustomWidgets$WidgetTranslation") + o.languageCode = property.NewPrimitive[string]("LanguageCode", property.DecodeString) + o.languageCode.Bind(&o.Base, 0) + o.text = property.NewPrimitive[string]("Text", property.DecodeString) + o.text.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.languageCode, o.text}) + return o +} + +// NewWidgetTranslation creates a new WidgetTranslation for user code. Marked dirty (bit 63 = new element). +func NewWidgetTranslation() *WidgetTranslation { + o := initWidgetTranslation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetValue creates a WidgetValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetValue() *WidgetValue { + o := &WidgetValue{} + o.SetTypeName("CustomWidgets$WidgetValue") + o.propType = property.NewByIdRef[element.Element]("TypePointer") + o.propType.Bind(&o.Base, 0) + o.primitiveValue = property.NewPrimitive[string]("PrimitiveValue", property.DecodeString) + o.primitiveValue.Bind(&o.Base, 1) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 2) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 3) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 4) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 5) + o.page = property.NewByNameRef[element.Element]("Page", "Forms$Page") + o.page.Bind(&o.Base, 6) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 7) + o.nanoflow = property.NewByNameRef[element.Element]("Nanoflow", "Microflows$Nanoflow") + o.nanoflow.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.image = property.NewByNameRef[element.Element]("Image", "Images$Image") + o.image.Bind(&o.Base, 10) + o.translatableValue = property.NewPart[element.Element]("TranslatableValue") + o.translatableValue.Bind(&o.Base, 11) + o.textTemplate = property.NewPart[element.Element]("TextTemplate") + o.textTemplate.Bind(&o.Base, 12) + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 13) + o.objects = property.NewPartList[element.Element]("Objects") + o.objects.Bind(&o.Base, 14) + o.action = property.NewPart[element.Element]("Action") + o.action.Bind(&o.Base, 15) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 16) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 17) + o.dataSource = property.NewPart[element.Element]("DataSource") + o.dataSource.Bind(&o.Base, 18) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 19) + o.selection = property.NewEnum[string]("Selection") + o.selection.Bind(&o.Base, 20) + o.SetProperties([]element.Property{o.propType, o.primitiveValue, o.entityPath, o.entityRef, o.attributePath, o.attributeRef, o.page, o.microflow, o.nanoflow, o.icon, o.image, o.translatableValue, o.textTemplate, o.xPathConstraint, o.objects, o.action, o.expression, o.widgets, o.dataSource, o.sourceVariable, o.selection}) + return o +} + +// NewWidgetValue creates a new WidgetValue for user code. Marked dirty (bit 63 = new element). +func NewWidgetValue() *WidgetValue { + o := initWidgetValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetValueType creates a WidgetValueType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetValueType() *WidgetValueType { + o := &WidgetValueType{} + o.SetTypeName("CustomWidgets$WidgetValueType") + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 0) + o.isList = property.NewPrimitive[bool]("IsList", property.DecodeBool) + o.isList.Bind(&o.Base, 1) + o.isLinked = property.NewPrimitive[bool]("IsLinked", property.DecodeBool) + o.isLinked.Bind(&o.Base, 2) + o.isMetaData = property.NewPrimitive[bool]("IsMetaData", property.DecodeBool) + o.isMetaData.Bind(&o.Base, 3) + o.entityProperty = property.NewPrimitive[string]("EntityProperty", property.DecodeString) + o.entityProperty.Bind(&o.Base, 4) + o.allowNonPersistableEntities = property.NewPrimitive[bool]("AllowNonPersistableEntities", property.DecodeBool) + o.allowNonPersistableEntities.Bind(&o.Base, 5) + o.isPath = property.NewEnum[string]("IsPath") + o.isPath.Bind(&o.Base, 6) + o.pathType = property.NewEnum[string]("PathType") + o.pathType.Bind(&o.Base, 7) + o.parameterIsList = property.NewPrimitive[bool]("ParameterIsList", property.DecodeBool) + o.parameterIsList.Bind(&o.Base, 8) + o.multiline = property.NewPrimitive[bool]("Multiline", property.DecodeBool) + o.multiline.Bind(&o.Base, 9) + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 10) + o.required = property.NewPrimitive[bool]("Required", property.DecodeBool) + o.required.Bind(&o.Base, 11) + o.onChangeProperty = property.NewPrimitive[string]("OnChangeProperty", property.DecodeString) + o.onChangeProperty.Bind(&o.Base, 12) + o.dataSourceProperty = property.NewPrimitive[string]("DataSourceProperty", property.DecodeString) + o.dataSourceProperty.Bind(&o.Base, 13) + o.universeDataSourceProperty = property.NewPrimitive[string]("UniverseDataSourceProperty", property.DecodeString) + o.universeDataSourceProperty.Bind(&o.Base, 14) + o.selectableObjectsProperty = property.NewPrimitive[string]("SelectableObjectsProperty", property.DecodeString) + o.selectableObjectsProperty.Bind(&o.Base, 15) + o.attributeTypes = property.NewEnumList[string]("AttributeTypes") + o.attributeTypes.Bind(&o.Base, 16) + o.associationTypes = property.NewEnumList[string]("AssociationTypes") + o.associationTypes.Bind(&o.Base, 17) + o.selectionTypes = property.NewEnumList[string]("SelectionTypes") + o.selectionTypes.Bind(&o.Base, 18) + o.enumerationValues = property.NewPartList[element.Element]("EnumerationValues") + o.enumerationValues.Bind(&o.Base, 19) + o.actionVariables = property.NewPartList[element.Element]("ActionVariables") + o.actionVariables.Bind(&o.Base, 20) + o.objectType = property.NewPart[element.Element]("ObjectType") + o.objectType.Bind(&o.Base, 21) + o.returnType = property.NewPart[element.Element]("ReturnType") + o.returnType.Bind(&o.Base, 22) + o.translations = property.NewPartList[element.Element]("Translations") + o.translations.Bind(&o.Base, 23) + o.setLabel = property.NewPrimitive[bool]("SetLabel", property.DecodeBool) + o.setLabel.Bind(&o.Base, 24) + o.defaultType = property.NewEnum[string]("DefaultType") + o.defaultType.Bind(&o.Base, 25) + o.allowUpload = property.NewPrimitive[bool]("AllowUpload", property.DecodeBool) + o.allowUpload.Bind(&o.Base, 26) + o.SetProperties([]element.Property{o.propType, o.isList, o.isLinked, o.isMetaData, o.entityProperty, o.allowNonPersistableEntities, o.isPath, o.pathType, o.parameterIsList, o.multiline, o.defaultValue, o.required, o.onChangeProperty, o.dataSourceProperty, o.universeDataSourceProperty, o.selectableObjectsProperty, o.attributeTypes, o.associationTypes, o.selectionTypes, o.enumerationValues, o.actionVariables, o.objectType, o.returnType, o.translations, o.setLabel, o.defaultType, o.allowUpload}) + return o +} + +// NewWidgetValueType creates a new WidgetValueType for user code. Marked dirty (bit 63 = new element). +func NewWidgetValueType() *WidgetValueType { + o := initWidgetValueType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("CustomWidgets$CustomWidget", func() element.Element { + return initCustomWidget() + }) + codec.DefaultRegistry.Register("CustomWidgets$CustomWidgetDatabaseSource", func() element.Element { + return initCustomWidgetDatabaseSource() + }) + codec.DefaultRegistry.Register("CustomWidgets$CustomWidgetType", func() element.Element { + return initCustomWidgetType() + }) + codec.DefaultRegistry.Register("CustomWidgets$CustomWidgetXPathSource", func() element.Element { + return initCustomWidgetXPathSource() + }) + codec.DefaultRegistry.Register("CustomWidgets$WidgetActionVariable", func() element.Element { + return initWidgetActionVariable() + }) + codec.DefaultRegistry.Register("CustomWidgets$WidgetEnumerationValue", func() element.Element { + return initWidgetEnumerationValue() + }) + codec.DefaultRegistry.Register("CustomWidgets$WidgetObject", func() element.Element { + return initWidgetObject() + }) + codec.DefaultRegistry.Register("CustomWidgets$WidgetObjectType", func() element.Element { + return initWidgetObjectType() + }) + codec.DefaultRegistry.Register("CustomWidgets$WidgetProperty", func() element.Element { + return initWidgetProperty() + }) + codec.DefaultRegistry.Register("CustomWidgets$WidgetPropertyType", func() element.Element { + return initWidgetPropertyType() + }) + codec.DefaultRegistry.Register("CustomWidgets$WidgetReturnType", func() element.Element { + return initWidgetReturnType() + }) + codec.DefaultRegistry.Register("CustomWidgets$WidgetTranslation", func() element.Element { + return initWidgetTranslation() + }) + codec.DefaultRegistry.Register("CustomWidgets$WidgetValue", func() element.Element { + return initWidgetValue() + }) + codec.DefaultRegistry.Register("CustomWidgets$WidgetValueType", func() element.Element { + return initWidgetValueType() + }) +} diff --git a/modelsdk/gen/customwidgets/version.go b/modelsdk/gen/customwidgets/version.go new file mode 100644 index 00000000..de213ddd --- /dev/null +++ b/modelsdk/gen/customwidgets/version.go @@ -0,0 +1,88 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package customwidgets + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "CustomWidgets$CustomWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "conditionalEditabilitySettings": {Introduced: "8.1.0"}, + "conditionalVisibilitySettings": {Introduced: "8.1.0"}, + "editable": {Introduced: "8.1.0"}, + "labelTemplate": {Introduced: "8.1.0"}, + }, + }, + "CustomWidgets$CustomWidgetType": { + Properties: map[string]version.PropertyVersionInfo{ + "experimentalApi": {Introduced: "7.0.0", Deleted: "7.1.0"}, + "helpUrl": {Introduced: "8.3.0"}, + "labeled": {Introduced: "7.23.0", Deleted: "8.0.0"}, + "objectType": {Required: true}, + "phoneGapEnabled": {Deleted: "10.0.0"}, + "pluginWidget": {Introduced: "7.19.0"}, + "studioCategory": {Introduced: "9.4.0"}, + "studioProCategory": {Introduced: "9.4.0"}, + "supportedPlatform": {Introduced: "8.0.0"}, + }, + }, + "CustomWidgets$WidgetObject": { + Properties: map[string]version.PropertyVersionInfo{ + "labelTemplate": {Introduced: "7.23.0", Deleted: "8.1.0"}, + "type": {}, + }, + }, + "CustomWidgets$WidgetProperty": { + Properties: map[string]version.PropertyVersionInfo{ + "type": {}, + "value": {}, + }, + }, + "CustomWidgets$WidgetPropertyType": { + Properties: map[string]version.PropertyVersionInfo{ + "valueType": {}, + }, + }, + "CustomWidgets$WidgetReturnType": { + Properties: map[string]version.PropertyVersionInfo{ + "type": {Introduced: "9.20.0"}, + }, + }, + "CustomWidgets$WidgetValue": { + Properties: map[string]version.PropertyVersionInfo{ + "action": {Introduced: "7.19.0", Required: true}, + "attributePath": {Deleted: "7.11.0"}, + "attributeRef": {Introduced: "7.11.0"}, + "dataSource": {Introduced: "8.3.0"}, + "entityPath": {Deleted: "7.11.0"}, + "entityRef": {Introduced: "7.11.0"}, + "expression": {Introduced: "8.0.0"}, + "icon": {Introduced: "8.0.0"}, + "nanoflow": {Introduced: "7.13.0"}, + "selection": {Introduced: "9.23.0"}, + "sourceVariable": {Introduced: "8.8.0"}, + "textTemplate": {Introduced: "7.23.0"}, + "type": {Required: true}, + "widgets": {Introduced: "8.2.0"}, + }, + }, + "CustomWidgets$WidgetValueType": { + Properties: map[string]version.PropertyVersionInfo{ + "actionVariables": {Introduced: "10.21.0"}, + "allowUpload": {Introduced: "11.8.0"}, + "associationTypes": {Introduced: "9.12.0"}, + "dataSourceProperty": {Introduced: "8.4.0"}, + "defaultType": {Introduced: "10.15.0"}, + "isLinked": {Introduced: "10.14.0"}, + "isMetaData": {Introduced: "10.14.0"}, + "onChangeProperty": {Introduced: "8.0.0"}, + "selectableObjectsProperty": {Introduced: "9.12.0"}, + "selectionTypes": {Introduced: "9.23.0"}, + "setLabel": {Introduced: "10.5.0"}, + "universeDataSourceProperty": {Introduced: "9.10.0", Deleted: "9.12.0"}, + }, + }, +} diff --git a/modelsdk/gen/databaseconnector/enums.go b/modelsdk/gen/databaseconnector/enums.go new file mode 100644 index 00000000..c98a121b --- /dev/null +++ b/modelsdk/gen/databaseconnector/enums.go @@ -0,0 +1,15 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package databaseconnector + +// QueryParameterMode enumerates the possible values for the QueryParameterMode type. +type QueryParameterMode = string + +const ( + QueryParameterModeUnknown QueryParameterMode = "Unknown" + QueryParameterModeIn QueryParameterMode = "In" + QueryParameterModeOut QueryParameterMode = "Out" + QueryParameterModeInOut QueryParameterMode = "InOut" +) diff --git a/modelsdk/gen/databaseconnector/refs.go b/modelsdk/gen/databaseconnector/refs.go new file mode 100644 index 00000000..e5c8eca2 --- /dev/null +++ b/modelsdk/gen/databaseconnector/refs.go @@ -0,0 +1,28 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package databaseconnector + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("DatabaseConnector$ColumnMapping", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DatabaseConnector$DatabaseConnection", []codec.RefMeta{ + {Prop: "ConnectionString", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "UserName", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "Password", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "LastSelectedQuery", Kind: codec.RefByName, Target: "DatabaseConnector$DatabaseQuery"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DatabaseConnector$ExecuteDatabaseQueryAction", []codec.RefMeta{ + {Prop: "Query", Kind: codec.RefByName, Target: "DatabaseConnector$DatabaseQuery"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DatabaseConnector$TableMapping", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DatabaseConnector$ValueAsConstant", []codec.RefMeta{ + {Prop: "Value", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) +} diff --git a/modelsdk/gen/databaseconnector/types.go b/modelsdk/gen/databaseconnector/types.go new file mode 100644 index 00000000..3ace55f6 --- /dev/null +++ b/modelsdk/gen/databaseconnector/types.go @@ -0,0 +1,1540 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package databaseconnector + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// AdditionalProperty +// ──────────────────────────────────────────────────────── + +type AdditionalProperty struct { + element.Base + key *property.Primitive[string] + value *property.Part[element.Element] +} + +// Key returns the value of the key property. +func (o *AdditionalProperty) Key() string { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *AdditionalProperty) SetKey(v string) { + o.key.Set(v) +} + +// Value returns the value of the value property. +func (o *AdditionalProperty) Value() element.Element { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *AdditionalProperty) SetValue(v element.Element) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AdditionalProperty) InitFromRaw(raw bson.Raw) { + o.key.Init(raw) + if child, err := codec.DecodeChild(raw, "Value"); err == nil { + o.value.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// AdditionalPropertyValue +// ──────────────────────────────────────────────────────── + +type AdditionalPropertyValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AdditionalPropertyValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ColumnMapping +// ──────────────────────────────────────────────────────── + +type ColumnMapping struct { + element.Base + columnName *property.Primitive[string] + sqlDataType *property.Part[element.Element] + attribute *property.ByNameRef[element.Element] +} + +// ColumnName returns the value of the columnName property. +func (o *ColumnMapping) ColumnName() string { + return o.columnName.Get() +} + +// SetColumnName sets the value of the columnName property. +func (o *ColumnMapping) SetColumnName(v string) { + o.columnName.Set(v) +} + +// SqlDataType returns the value of the sqlDataType property. +func (o *ColumnMapping) SqlDataType() element.Element { + return o.sqlDataType.Get() +} + +// SetSqlDataType sets the value of the sqlDataType property. +func (o *ColumnMapping) SetSqlDataType(v element.Element) { + o.sqlDataType.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ColumnMapping) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ColumnMapping) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ColumnMapping) InitFromRaw(raw bson.Raw) { + o.columnName.Init(raw) + if child, err := codec.DecodeChild(raw, "SqlDataType"); err == nil { + o.sqlDataType.SetFromDecode(child) + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ConnectionDetails +// ──────────────────────────────────────────────────────── + +type ConnectionDetails struct { + element.Base + host *property.Primitive[string] + port *property.Primitive[int32] + databaseName *property.Primitive[string] +} + +// Host returns the value of the host property. +func (o *ConnectionDetails) Host() string { + return o.host.Get() +} + +// SetHost sets the value of the host property. +func (o *ConnectionDetails) SetHost(v string) { + o.host.Set(v) +} + +// Port returns the value of the port property. +func (o *ConnectionDetails) Port() int32 { + return o.port.Get() +} + +// SetPort sets the value of the port property. +func (o *ConnectionDetails) SetPort(v int32) { + o.port.Set(v) +} + +// DatabaseName returns the value of the databaseName property. +func (o *ConnectionDetails) DatabaseName() string { + return o.databaseName.Get() +} + +// SetDatabaseName sets the value of the databaseName property. +func (o *ConnectionDetails) SetDatabaseName(v string) { + o.databaseName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectionDetails) InitFromRaw(raw bson.Raw) { + o.host.Init(raw) + o.port.Init(raw) + o.databaseName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConnectionInput +// ──────────────────────────────────────────────────────── + +type ConnectionInput struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectionInput) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ConnectionParameterMapping +// ──────────────────────────────────────────────────────── + +type ConnectionParameterMapping struct { + element.Base + parameterName *property.Primitive[string] + value *property.Primitive[string] +} + +// ParameterName returns the value of the parameterName property. +func (o *ConnectionParameterMapping) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *ConnectionParameterMapping) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// Value returns the value of the value property. +func (o *ConnectionParameterMapping) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *ConnectionParameterMapping) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectionParameterMapping) InitFromRaw(raw bson.Raw) { + o.parameterName.Init(raw) + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConnectionParts +// ──────────────────────────────────────────────────────── + +type ConnectionParts struct { + element.Base + host *property.Primitive[string] + port *property.Primitive[int32] + databaseName *property.Primitive[string] +} + +// Host returns the value of the host property. +func (o *ConnectionParts) Host() string { + return o.host.Get() +} + +// SetHost sets the value of the host property. +func (o *ConnectionParts) SetHost(v string) { + o.host.Set(v) +} + +// Port returns the value of the port property. +func (o *ConnectionParts) Port() int32 { + return o.port.Get() +} + +// SetPort sets the value of the port property. +func (o *ConnectionParts) SetPort(v int32) { + o.port.Set(v) +} + +// DatabaseName returns the value of the databaseName property. +func (o *ConnectionParts) DatabaseName() string { + return o.databaseName.Get() +} + +// SetDatabaseName sets the value of the databaseName property. +func (o *ConnectionParts) SetDatabaseName(v string) { + o.databaseName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectionParts) InitFromRaw(raw bson.Raw) { + o.host.Init(raw) + o.port.Init(raw) + o.databaseName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConnectionString +// ──────────────────────────────────────────────────────── + +type ConnectionString struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *ConnectionString) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *ConnectionString) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConnectionString) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DatabaseConnection +// ──────────────────────────────────────────────────────── + +type DatabaseConnection struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + databaseType *property.Primitive[string] + connectionInput *property.Part[element.Element] + connectionDetails *property.Part[element.Element] + connectionString *property.ByNameRef[element.Element] + userName *property.ByNameRef[element.Element] + password *property.ByNameRef[element.Element] + lastSelectedQuery *property.ByNameRef[element.Element] + queries *property.PartList[element.Element] + additionalProperties *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *DatabaseConnection) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DatabaseConnection) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *DatabaseConnection) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *DatabaseConnection) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *DatabaseConnection) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *DatabaseConnection) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *DatabaseConnection) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *DatabaseConnection) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// DatabaseType returns the value of the databaseType property. +func (o *DatabaseConnection) DatabaseType() string { + return o.databaseType.Get() +} + +// SetDatabaseType sets the value of the databaseType property. +func (o *DatabaseConnection) SetDatabaseType(v string) { + o.databaseType.Set(v) +} + +// ConnectionInput returns the value of the connectionInput property. +func (o *DatabaseConnection) ConnectionInput() element.Element { + return o.connectionInput.Get() +} + +// SetConnectionInput sets the value of the connectionInput property. +func (o *DatabaseConnection) SetConnectionInput(v element.Element) { + o.connectionInput.Set(v) +} + +// ConnectionDetails returns the value of the connectionDetails property. +func (o *DatabaseConnection) ConnectionDetails() element.Element { + return o.connectionDetails.Get() +} + +// SetConnectionDetails sets the value of the connectionDetails property. +func (o *DatabaseConnection) SetConnectionDetails(v element.Element) { + o.connectionDetails.Set(v) +} + +// ConnectionStringQualifiedName returns the value of the connectionString property. +func (o *DatabaseConnection) ConnectionStringQualifiedName() string { + return o.connectionString.QualifiedName() +} + +// SetConnectionStringQualifiedName sets the value of the connectionString property. +func (o *DatabaseConnection) SetConnectionStringQualifiedName(v string) { + o.connectionString.SetQualifiedName(v) +} + +// UserNameQualifiedName returns the value of the userName property. +func (o *DatabaseConnection) UserNameQualifiedName() string { + return o.userName.QualifiedName() +} + +// SetUserNameQualifiedName sets the value of the userName property. +func (o *DatabaseConnection) SetUserNameQualifiedName(v string) { + o.userName.SetQualifiedName(v) +} + +// PasswordQualifiedName returns the value of the password property. +func (o *DatabaseConnection) PasswordQualifiedName() string { + return o.password.QualifiedName() +} + +// SetPasswordQualifiedName sets the value of the password property. +func (o *DatabaseConnection) SetPasswordQualifiedName(v string) { + o.password.SetQualifiedName(v) +} + +// LastSelectedQueryQualifiedName returns the value of the lastSelectedQuery property. +func (o *DatabaseConnection) LastSelectedQueryQualifiedName() string { + return o.lastSelectedQuery.QualifiedName() +} + +// SetLastSelectedQueryQualifiedName sets the value of the lastSelectedQuery property. +func (o *DatabaseConnection) SetLastSelectedQueryQualifiedName(v string) { + o.lastSelectedQuery.SetQualifiedName(v) +} + +// QueriesItems returns the value of the queries property. +func (o *DatabaseConnection) QueriesItems() []element.Element { + return o.queries.Items() +} + +// AddQueries appends a child element to the queries list. +func (o *DatabaseConnection) AddQueries(v element.Element) { + o.queries.Append(v) +} + +// RemoveQueries removes the element at the given index from the queries list. +func (o *DatabaseConnection) RemoveQueries(index int) { + o.queries.Remove(index) +} + +// AdditionalPropertiesItems returns the value of the additionalProperties property. +func (o *DatabaseConnection) AdditionalPropertiesItems() []element.Element { + return o.additionalProperties.Items() +} + +// AddAdditionalProperties appends a child element to the additionalProperties list. +func (o *DatabaseConnection) AddAdditionalProperties(v element.Element) { + o.additionalProperties.Append(v) +} + +// RemoveAdditionalProperties removes the element at the given index from the additionalProperties list. +func (o *DatabaseConnection) RemoveAdditionalProperties(index int) { + o.additionalProperties.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DatabaseConnection) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.databaseType.Init(raw) + if child, err := codec.DecodeChild(raw, "ConnectionInput"); err == nil { + o.connectionInput.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConnectionDetails"); err == nil { + o.connectionDetails.SetFromDecode(child) + } + if val, err := raw.LookupErr("ConnectionString"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.connectionString.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("UserName"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.userName.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Password"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.password.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("LastSelectedQuery"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.lastSelectedQuery.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Queries"); err == nil { + for _, child := range children { + o.queries.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "AdditionalProperties"); err == nil { + for _, child := range children { + o.additionalProperties.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// DatabaseQuery +// ──────────────────────────────────────────────────────── + +type DatabaseQuery struct { + element.Base + name *property.Primitive[string] + query *property.Primitive[string] + tableMapping *property.Part[element.Element] + tableMappings *property.PartList[element.Element] + parameters *property.PartList[element.Element] + queryType *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *DatabaseQuery) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DatabaseQuery) SetName(v string) { + o.name.Set(v) +} + +// Query returns the value of the query property. +func (o *DatabaseQuery) Query() string { + return o.query.Get() +} + +// SetQuery sets the value of the query property. +func (o *DatabaseQuery) SetQuery(v string) { + o.query.Set(v) +} + +// TableMapping returns the value of the tableMapping property. +func (o *DatabaseQuery) TableMapping() element.Element { + return o.tableMapping.Get() +} + +// SetTableMapping sets the value of the tableMapping property. +func (o *DatabaseQuery) SetTableMapping(v element.Element) { + o.tableMapping.Set(v) +} + +// TableMappingsItems returns the value of the tableMappings property. +func (o *DatabaseQuery) TableMappingsItems() []element.Element { + return o.tableMappings.Items() +} + +// AddTableMappings appends a child element to the tableMappings list. +func (o *DatabaseQuery) AddTableMappings(v element.Element) { + o.tableMappings.Append(v) +} + +// RemoveTableMappings removes the element at the given index from the tableMappings list. +func (o *DatabaseQuery) RemoveTableMappings(index int) { + o.tableMappings.Remove(index) +} + +// ParametersItems returns the value of the parameters property. +func (o *DatabaseQuery) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *DatabaseQuery) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *DatabaseQuery) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// QueryType returns the value of the queryType property. +func (o *DatabaseQuery) QueryType() int32 { + return o.queryType.Get() +} + +// SetQueryType sets the value of the queryType property. +func (o *DatabaseQuery) SetQueryType(v int32) { + o.queryType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DatabaseQuery) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.query.Init(raw) + if child, err := codec.DecodeChild(raw, "TableMapping"); err == nil { + o.tableMapping.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "TableMappings"); err == nil { + for _, child := range children { + o.tableMappings.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + o.queryType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ExecuteDatabaseQueryAction +// ──────────────────────────────────────────────────────── + +type ExecuteDatabaseQueryAction struct { + element.Base + errorHandlingType *property.Enum[string] + query *property.ByNameRef[element.Element] + connectionParameterMappings *property.PartList[element.Element] + parameterMappings *property.PartList[element.Element] + dynamicQuery *property.Primitive[string] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ExecuteDatabaseQueryAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ExecuteDatabaseQueryAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// QueryQualifiedName returns the value of the query property. +func (o *ExecuteDatabaseQueryAction) QueryQualifiedName() string { + return o.query.QualifiedName() +} + +// SetQueryQualifiedName sets the value of the query property. +func (o *ExecuteDatabaseQueryAction) SetQueryQualifiedName(v string) { + o.query.SetQualifiedName(v) +} + +// ConnectionParameterMappingsItems returns the value of the connectionParameterMappings property. +func (o *ExecuteDatabaseQueryAction) ConnectionParameterMappingsItems() []element.Element { + return o.connectionParameterMappings.Items() +} + +// AddConnectionParameterMappings appends a child element to the connectionParameterMappings list. +func (o *ExecuteDatabaseQueryAction) AddConnectionParameterMappings(v element.Element) { + o.connectionParameterMappings.Append(v) +} + +// RemoveConnectionParameterMappings removes the element at the given index from the connectionParameterMappings list. +func (o *ExecuteDatabaseQueryAction) RemoveConnectionParameterMappings(index int) { + o.connectionParameterMappings.Remove(index) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *ExecuteDatabaseQueryAction) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *ExecuteDatabaseQueryAction) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *ExecuteDatabaseQueryAction) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// DynamicQuery returns the value of the dynamicQuery property. +func (o *ExecuteDatabaseQueryAction) DynamicQuery() string { + return o.dynamicQuery.Get() +} + +// SetDynamicQuery sets the value of the dynamicQuery property. +func (o *ExecuteDatabaseQueryAction) SetDynamicQuery(v string) { + o.dynamicQuery.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *ExecuteDatabaseQueryAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *ExecuteDatabaseQueryAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExecuteDatabaseQueryAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.errorHandlingType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Query"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.query.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "ConnectionParameterMappings"); err == nil { + for _, child := range children { + o.connectionParameterMappings.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + o.dynamicQuery.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SqlDataType +// ──────────────────────────────────────────────────────── + +type SqlDataType struct { + element.Base + dataTypeName *property.Primitive[string] +} + +// DataTypeName returns the value of the dataTypeName property. +func (o *SqlDataType) DataTypeName() string { + return o.dataTypeName.Get() +} + +// SetDataTypeName sets the value of the dataTypeName property. +func (o *SqlDataType) SetDataTypeName(v string) { + o.dataTypeName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SqlDataType) InitFromRaw(raw bson.Raw) { + o.dataTypeName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LimitedLengthSqlDataType +// ──────────────────────────────────────────────────────── + +type LimitedLengthSqlDataType struct { + element.Base + dataTypeName *property.Primitive[string] + length *property.Primitive[int32] +} + +// DataTypeName returns the value of the dataTypeName property. +func (o *LimitedLengthSqlDataType) DataTypeName() string { + return o.dataTypeName.Get() +} + +// SetDataTypeName sets the value of the dataTypeName property. +func (o *LimitedLengthSqlDataType) SetDataTypeName(v string) { + o.dataTypeName.Set(v) +} + +// Length returns the value of the length property. +func (o *LimitedLengthSqlDataType) Length() int32 { + return o.length.Get() +} + +// SetLength sets the value of the length property. +func (o *LimitedLengthSqlDataType) SetLength(v int32) { + o.length.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LimitedLengthSqlDataType) InitFromRaw(raw bson.Raw) { + o.dataTypeName.Init(raw) + o.length.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// QueryParameter +// ──────────────────────────────────────────────────────── + +type QueryParameter struct { + element.Base + parameterName *property.Primitive[string] + sqlDataType *property.Part[element.Element] + dataType *property.Part[element.Element] + defaultValue *property.Primitive[string] + mode *property.Enum[string] + databaseParameterName *property.Primitive[string] + emptyValueBecomesNull *property.Primitive[bool] + tableMapping *property.Part[element.Element] +} + +// ParameterName returns the value of the parameterName property. +func (o *QueryParameter) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *QueryParameter) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// SqlDataType returns the value of the sqlDataType property. +func (o *QueryParameter) SqlDataType() element.Element { + return o.sqlDataType.Get() +} + +// SetSqlDataType sets the value of the sqlDataType property. +func (o *QueryParameter) SetSqlDataType(v element.Element) { + o.sqlDataType.Set(v) +} + +// DataType returns the value of the dataType property. +func (o *QueryParameter) DataType() element.Element { + return o.dataType.Get() +} + +// SetDataType sets the value of the dataType property. +func (o *QueryParameter) SetDataType(v element.Element) { + o.dataType.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *QueryParameter) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *QueryParameter) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// Mode returns the value of the mode property. +func (o *QueryParameter) Mode() string { + return o.mode.Get() +} + +// SetMode sets the value of the mode property. +func (o *QueryParameter) SetMode(v string) { + o.mode.Set(v) +} + +// DatabaseParameterName returns the value of the databaseParameterName property. +func (o *QueryParameter) DatabaseParameterName() string { + return o.databaseParameterName.Get() +} + +// SetDatabaseParameterName sets the value of the databaseParameterName property. +func (o *QueryParameter) SetDatabaseParameterName(v string) { + o.databaseParameterName.Set(v) +} + +// EmptyValueBecomesNull returns the value of the emptyValueBecomesNull property. +func (o *QueryParameter) EmptyValueBecomesNull() bool { + return o.emptyValueBecomesNull.Get() +} + +// SetEmptyValueBecomesNull sets the value of the emptyValueBecomesNull property. +func (o *QueryParameter) SetEmptyValueBecomesNull(v bool) { + o.emptyValueBecomesNull.Set(v) +} + +// TableMapping returns the value of the tableMapping property. +func (o *QueryParameter) TableMapping() element.Element { + return o.tableMapping.Get() +} + +// SetTableMapping sets the value of the tableMapping property. +func (o *QueryParameter) SetTableMapping(v element.Element) { + o.tableMapping.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueryParameter) InitFromRaw(raw bson.Raw) { + o.parameterName.Init(raw) + if child, err := codec.DecodeChild(raw, "SqlDataType"); err == nil { + o.sqlDataType.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataType"); err == nil { + o.dataType.SetFromDecode(child) + } + o.defaultValue.Init(raw) + if val, err := raw.LookupErr("Mode"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.mode.SetFromDecode(s) + } + } + o.databaseParameterName.Init(raw) + o.emptyValueBecomesNull.Init(raw) + if child, err := codec.DecodeChild(raw, "TableMapping"); err == nil { + o.tableMapping.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// QueryParameterMapping +// ──────────────────────────────────────────────────────── + +type QueryParameterMapping struct { + element.Base + parameterName *property.Primitive[string] + value *property.Primitive[string] +} + +// ParameterName returns the value of the parameterName property. +func (o *QueryParameterMapping) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *QueryParameterMapping) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// Value returns the value of the value property. +func (o *QueryParameterMapping) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *QueryParameterMapping) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueryParameterMapping) InitFromRaw(raw bson.Raw) { + o.parameterName.Init(raw) + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SimpleSqlDataType +// ──────────────────────────────────────────────────────── + +type SimpleSqlDataType struct { + element.Base + dataTypeName *property.Primitive[string] +} + +// DataTypeName returns the value of the dataTypeName property. +func (o *SimpleSqlDataType) DataTypeName() string { + return o.dataTypeName.Get() +} + +// SetDataTypeName sets the value of the dataTypeName property. +func (o *SimpleSqlDataType) SetDataTypeName(v string) { + o.dataTypeName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SimpleSqlDataType) InitFromRaw(raw bson.Raw) { + o.dataTypeName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TableMapping +// ──────────────────────────────────────────────────────── + +type TableMapping struct { + element.Base + tableName *property.Primitive[string] + entity *property.ByNameRef[element.Element] + columns *property.PartList[element.Element] +} + +// TableName returns the value of the tableName property. +func (o *TableMapping) TableName() string { + return o.tableName.Get() +} + +// SetTableName sets the value of the tableName property. +func (o *TableMapping) SetTableName(v string) { + o.tableName.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *TableMapping) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *TableMapping) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ColumnsItems returns the value of the columns property. +func (o *TableMapping) ColumnsItems() []element.Element { + return o.columns.Items() +} + +// AddColumns appends a child element to the columns list. +func (o *TableMapping) AddColumns(v element.Element) { + o.columns.Append(v) +} + +// RemoveColumns removes the element at the given index from the columns list. +func (o *TableMapping) RemoveColumns(index int) { + o.columns.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TableMapping) InitFromRaw(raw bson.Raw) { + o.tableName.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Columns"); err == nil { + for _, child := range children { + o.columns.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ValueAsConstant +// ──────────────────────────────────────────────────────── + +type ValueAsConstant struct { + element.Base + value *property.ByNameRef[element.Element] +} + +// ValueQualifiedName returns the value of the value property. +func (o *ValueAsConstant) ValueQualifiedName() string { + return o.value.QualifiedName() +} + +// SetValueQualifiedName sets the value of the value property. +func (o *ValueAsConstant) SetValueQualifiedName(v string) { + o.value.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ValueAsConstant) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Value"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.value.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ValueAsString +// ──────────────────────────────────────────────────────── + +type ValueAsString struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *ValueAsString) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *ValueAsString) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ValueAsString) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initAdditionalProperty creates a AdditionalProperty with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAdditionalProperty() *AdditionalProperty { + o := &AdditionalProperty{} + o.SetTypeName("DatabaseConnector$AdditionalProperty") + o.key = property.NewPrimitive[string]("Key", property.DecodeString) + o.key.Bind(&o.Base, 0) + o.value = property.NewPart[element.Element]("Value") + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.key, o.value}) + return o +} + +// NewAdditionalProperty creates a new AdditionalProperty for user code. Marked dirty (bit 63 = new element). +func NewAdditionalProperty() *AdditionalProperty { + o := initAdditionalProperty() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initColumnMapping creates a ColumnMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initColumnMapping() *ColumnMapping { + o := &ColumnMapping{} + o.SetTypeName("DatabaseConnector$ColumnMapping") + o.columnName = property.NewPrimitive[string]("ColumnName", property.DecodeString) + o.columnName.Bind(&o.Base, 0) + o.sqlDataType = property.NewPart[element.Element]("SqlDataType") + o.sqlDataType.Bind(&o.Base, 1) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.columnName, o.sqlDataType, o.attribute}) + return o +} + +// NewColumnMapping creates a new ColumnMapping for user code. Marked dirty (bit 63 = new element). +func NewColumnMapping() *ColumnMapping { + o := initColumnMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConnectionDetails creates a ConnectionDetails with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnectionDetails() *ConnectionDetails { + o := &ConnectionDetails{} + o.SetTypeName("DatabaseConnector$ConnectionDetails") + o.host = property.NewPrimitive[string]("Host", property.DecodeString) + o.host.Bind(&o.Base, 0) + o.port = property.NewPrimitive[int32]("Port", property.DecodeInt32) + o.port.Bind(&o.Base, 1) + o.databaseName = property.NewPrimitive[string]("DatabaseName", property.DecodeString) + o.databaseName.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.host, o.port, o.databaseName}) + return o +} + +// NewConnectionDetails creates a new ConnectionDetails for user code. Marked dirty (bit 63 = new element). +func NewConnectionDetails() *ConnectionDetails { + o := initConnectionDetails() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConnectionParameterMapping creates a ConnectionParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnectionParameterMapping() *ConnectionParameterMapping { + o := &ConnectionParameterMapping{} + o.SetTypeName("DatabaseConnector$ConnectionParameterMapping") + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameterName, o.value}) + return o +} + +// NewConnectionParameterMapping creates a new ConnectionParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewConnectionParameterMapping() *ConnectionParameterMapping { + o := initConnectionParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConnectionParts creates a ConnectionParts with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnectionParts() *ConnectionParts { + o := &ConnectionParts{} + o.SetTypeName("DatabaseConnector$ConnectionParts") + o.host = property.NewPrimitive[string]("Host", property.DecodeString) + o.host.Bind(&o.Base, 0) + o.port = property.NewPrimitive[int32]("Port", property.DecodeInt32) + o.port.Bind(&o.Base, 1) + o.databaseName = property.NewPrimitive[string]("DatabaseName", property.DecodeString) + o.databaseName.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.host, o.port, o.databaseName}) + return o +} + +// NewConnectionParts creates a new ConnectionParts for user code. Marked dirty (bit 63 = new element). +func NewConnectionParts() *ConnectionParts { + o := initConnectionParts() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConnectionString creates a ConnectionString with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConnectionString() *ConnectionString { + o := &ConnectionString{} + o.SetTypeName("DatabaseConnector$ConnectionString") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value}) + return o +} + +// NewConnectionString creates a new ConnectionString for user code. Marked dirty (bit 63 = new element). +func NewConnectionString() *ConnectionString { + o := initConnectionString() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDatabaseConnection creates a DatabaseConnection with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDatabaseConnection() *DatabaseConnection { + o := &DatabaseConnection{} + o.SetTypeName("DatabaseConnector$DatabaseConnection") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.databaseType = property.NewPrimitive[string]("DatabaseType", property.DecodeString) + o.databaseType.Bind(&o.Base, 4) + o.connectionInput = property.NewPart[element.Element]("ConnectionInput") + o.connectionInput.Bind(&o.Base, 5) + o.connectionDetails = property.NewPart[element.Element]("ConnectionDetails") + o.connectionDetails.Bind(&o.Base, 6) + o.connectionString = property.NewByNameRef[element.Element]("ConnectionString", "Constants$Constant") + o.connectionString.Bind(&o.Base, 7) + o.userName = property.NewByNameRef[element.Element]("UserName", "Constants$Constant") + o.userName.Bind(&o.Base, 8) + o.password = property.NewByNameRef[element.Element]("Password", "Constants$Constant") + o.password.Bind(&o.Base, 9) + o.lastSelectedQuery = property.NewByNameRef[element.Element]("LastSelectedQuery", "DatabaseConnector$DatabaseQuery") + o.lastSelectedQuery.Bind(&o.Base, 10) + o.queries = property.NewPartList[element.Element]("Queries") + o.queries.Bind(&o.Base, 11) + o.additionalProperties = property.NewPartList[element.Element]("AdditionalProperties") + o.additionalProperties.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.databaseType, o.connectionInput, o.connectionDetails, o.connectionString, o.userName, o.password, o.lastSelectedQuery, o.queries, o.additionalProperties}) + return o +} + +// NewDatabaseConnection creates a new DatabaseConnection for user code. Marked dirty (bit 63 = new element). +func NewDatabaseConnection() *DatabaseConnection { + o := initDatabaseConnection() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDatabaseQuery creates a DatabaseQuery with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDatabaseQuery() *DatabaseQuery { + o := &DatabaseQuery{} + o.SetTypeName("DatabaseConnector$DatabaseQuery") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.query = property.NewPrimitive[string]("Query", property.DecodeString) + o.query.Bind(&o.Base, 1) + o.tableMapping = property.NewPart[element.Element]("TableMapping") + o.tableMapping.Bind(&o.Base, 2) + o.tableMappings = property.NewPartList[element.Element]("TableMappings") + o.tableMappings.Bind(&o.Base, 3) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 4) + o.queryType = property.NewPrimitive[int32]("QueryType", property.DecodeInt32) + o.queryType.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.query, o.tableMapping, o.tableMappings, o.parameters, o.queryType}) + return o +} + +// NewDatabaseQuery creates a new DatabaseQuery for user code. Marked dirty (bit 63 = new element). +func NewDatabaseQuery() *DatabaseQuery { + o := initDatabaseQuery() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExecuteDatabaseQueryAction creates a ExecuteDatabaseQueryAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExecuteDatabaseQueryAction() *ExecuteDatabaseQueryAction { + o := &ExecuteDatabaseQueryAction{} + o.SetTypeName("DatabaseConnector$ExecuteDatabaseQueryAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.query = property.NewByNameRef[element.Element]("Query", "DatabaseConnector$DatabaseQuery") + o.query.Bind(&o.Base, 1) + o.connectionParameterMappings = property.NewPartList[element.Element]("ConnectionParameterMappings") + o.connectionParameterMappings.Bind(&o.Base, 2) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 3) + o.dynamicQuery = property.NewPrimitive[string]("DynamicQuery", property.DecodeString) + o.dynamicQuery.Bind(&o.Base, 4) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.errorHandlingType, o.query, o.connectionParameterMappings, o.parameterMappings, o.dynamicQuery, o.outputVariableName}) + return o +} + +// NewExecuteDatabaseQueryAction creates a new ExecuteDatabaseQueryAction for user code. Marked dirty (bit 63 = new element). +func NewExecuteDatabaseQueryAction() *ExecuteDatabaseQueryAction { + o := initExecuteDatabaseQueryAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLimitedLengthSqlDataType creates a LimitedLengthSqlDataType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLimitedLengthSqlDataType() *LimitedLengthSqlDataType { + o := &LimitedLengthSqlDataType{} + o.SetTypeName("DatabaseConnector$LimitedLengthSqlDataType") + o.dataTypeName = property.NewPrimitive[string]("DataTypeName", property.DecodeString) + o.dataTypeName.Bind(&o.Base, 0) + o.length = property.NewPrimitive[int32]("Length", property.DecodeInt32) + o.length.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.dataTypeName, o.length}) + return o +} + +// NewLimitedLengthSqlDataType creates a new LimitedLengthSqlDataType for user code. Marked dirty (bit 63 = new element). +func NewLimitedLengthSqlDataType() *LimitedLengthSqlDataType { + o := initLimitedLengthSqlDataType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initQueryParameter creates a QueryParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initQueryParameter() *QueryParameter { + o := &QueryParameter{} + o.SetTypeName("DatabaseConnector$QueryParameter") + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 0) + o.sqlDataType = property.NewPart[element.Element]("SqlDataType") + o.sqlDataType.Bind(&o.Base, 1) + o.dataType = property.NewPart[element.Element]("DataType") + o.dataType.Bind(&o.Base, 2) + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 3) + o.mode = property.NewEnum[string]("Mode") + o.mode.Bind(&o.Base, 4) + o.databaseParameterName = property.NewPrimitive[string]("DatabaseParameterName", property.DecodeString) + o.databaseParameterName.Bind(&o.Base, 5) + o.emptyValueBecomesNull = property.NewPrimitive[bool]("EmptyValueBecomesNull", property.DecodeBool) + o.emptyValueBecomesNull.Bind(&o.Base, 6) + o.tableMapping = property.NewPart[element.Element]("TableMapping") + o.tableMapping.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.parameterName, o.sqlDataType, o.dataType, o.defaultValue, o.mode, o.databaseParameterName, o.emptyValueBecomesNull, o.tableMapping}) + return o +} + +// NewQueryParameter creates a new QueryParameter for user code. Marked dirty (bit 63 = new element). +func NewQueryParameter() *QueryParameter { + o := initQueryParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initQueryParameterMapping creates a QueryParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initQueryParameterMapping() *QueryParameterMapping { + o := &QueryParameterMapping{} + o.SetTypeName("DatabaseConnector$QueryParameterMapping") + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameterName, o.value}) + return o +} + +// NewQueryParameterMapping creates a new QueryParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewQueryParameterMapping() *QueryParameterMapping { + o := initQueryParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSimpleSqlDataType creates a SimpleSqlDataType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSimpleSqlDataType() *SimpleSqlDataType { + o := &SimpleSqlDataType{} + o.SetTypeName("DatabaseConnector$SimpleSqlDataType") + o.dataTypeName = property.NewPrimitive[string]("DataTypeName", property.DecodeString) + o.dataTypeName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.dataTypeName}) + return o +} + +// NewSimpleSqlDataType creates a new SimpleSqlDataType for user code. Marked dirty (bit 63 = new element). +func NewSimpleSqlDataType() *SimpleSqlDataType { + o := initSimpleSqlDataType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTableMapping creates a TableMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTableMapping() *TableMapping { + o := &TableMapping{} + o.SetTypeName("DatabaseConnector$TableMapping") + o.tableName = property.NewPrimitive[string]("TableName", property.DecodeString) + o.tableName.Bind(&o.Base, 0) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 1) + o.columns = property.NewPartList[element.Element]("Columns") + o.columns.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.tableName, o.entity, o.columns}) + return o +} + +// NewTableMapping creates a new TableMapping for user code. Marked dirty (bit 63 = new element). +func NewTableMapping() *TableMapping { + o := initTableMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initValueAsConstant creates a ValueAsConstant with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initValueAsConstant() *ValueAsConstant { + o := &ValueAsConstant{} + o.SetTypeName("DatabaseConnector$ValueAsConstant") + o.value = property.NewByNameRef[element.Element]("Value", "Constants$Constant") + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value}) + return o +} + +// NewValueAsConstant creates a new ValueAsConstant for user code. Marked dirty (bit 63 = new element). +func NewValueAsConstant() *ValueAsConstant { + o := initValueAsConstant() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initValueAsString creates a ValueAsString with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initValueAsString() *ValueAsString { + o := &ValueAsString{} + o.SetTypeName("DatabaseConnector$ValueAsString") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value}) + return o +} + +// NewValueAsString creates a new ValueAsString for user code. Marked dirty (bit 63 = new element). +func NewValueAsString() *ValueAsString { + o := initValueAsString() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("DatabaseConnector$AdditionalProperty", func() element.Element { + return initAdditionalProperty() + }) + codec.DefaultRegistry.Register("DatabaseConnector$ColumnMapping", func() element.Element { + return initColumnMapping() + }) + codec.DefaultRegistry.Register("DatabaseConnector$ConnectionDetails", func() element.Element { + return initConnectionDetails() + }) + codec.DefaultRegistry.Register("DatabaseConnector$ConnectionParameterMapping", func() element.Element { + return initConnectionParameterMapping() + }) + codec.DefaultRegistry.Register("DatabaseConnector$ConnectionParts", func() element.Element { + return initConnectionParts() + }) + codec.DefaultRegistry.Register("DatabaseConnector$ConnectionString", func() element.Element { + return initConnectionString() + }) + codec.DefaultRegistry.Register("DatabaseConnector$DatabaseConnection", func() element.Element { + return initDatabaseConnection() + }) + codec.DefaultRegistry.Register("DatabaseConnector$DatabaseQuery", func() element.Element { + return initDatabaseQuery() + }) + codec.DefaultRegistry.Register("DatabaseConnector$ExecuteDatabaseQueryAction", func() element.Element { + return initExecuteDatabaseQueryAction() + }) + codec.DefaultRegistry.Register("DatabaseConnector$LimitedLengthSqlDataType", func() element.Element { + return initLimitedLengthSqlDataType() + }) + codec.DefaultRegistry.Register("DatabaseConnector$QueryParameter", func() element.Element { + return initQueryParameter() + }) + codec.DefaultRegistry.Register("DatabaseConnector$QueryParameterMapping", func() element.Element { + return initQueryParameterMapping() + }) + codec.DefaultRegistry.Register("DatabaseConnector$SimpleSqlDataType", func() element.Element { + return initSimpleSqlDataType() + }) + codec.DefaultRegistry.Register("DatabaseConnector$TableMapping", func() element.Element { + return initTableMapping() + }) + codec.DefaultRegistry.Register("DatabaseConnector$ValueAsConstant", func() element.Element { + return initValueAsConstant() + }) + codec.DefaultRegistry.Register("DatabaseConnector$ValueAsString", func() element.Element { + return initValueAsString() + }) +} diff --git a/modelsdk/gen/databaseconnector/version.go b/modelsdk/gen/databaseconnector/version.go new file mode 100644 index 00000000..ccad05b7 --- /dev/null +++ b/modelsdk/gen/databaseconnector/version.go @@ -0,0 +1,54 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package databaseconnector + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "DatabaseConnector$ColumnMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Required: true}, + }, + }, + "DatabaseConnector$DatabaseConnection": { + Properties: map[string]version.PropertyVersionInfo{ + "additionalProperties": {Introduced: "10.12.0"}, + "connectionDetails": {Deleted: "10.0.0"}, + "connectionInput": {Introduced: "10.0.0"}, + "lastSelectedQuery": {Introduced: "10.0.0"}, + "queries": {Public: true}, + }, + }, + "DatabaseConnector$DatabaseQuery": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "queryType": {Introduced: "10.12.0"}, + "tableMapping": {Deleted: "10.12.0"}, + "tableMappings": {Introduced: "10.12.0"}, + }, + }, + "DatabaseConnector$ExecuteDatabaseQueryAction": { + Properties: map[string]version.PropertyVersionInfo{ + "connectionParameterMappings": {Introduced: "11.1.0"}, + "dynamicQuery": {Introduced: "11.3.0"}, + "query": {}, + }, + }, + "DatabaseConnector$QueryParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "dataType": {Required: true}, + "databaseParameterName": {Introduced: "10.12.0"}, + "emptyValueBecomesNull": {Introduced: "10.12.0"}, + "mode": {Introduced: "10.10.0"}, + "tableMapping": {Introduced: "11.0.0"}, + }, + }, + "DatabaseConnector$TableMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/datasets/enums.go b/modelsdk/gen/datasets/enums.go new file mode 100644 index 00000000..c400f6ab --- /dev/null +++ b/modelsdk/gen/datasets/enums.go @@ -0,0 +1,29 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datasets + +// DateTimeIntervalLength enumerates the possible values for the DateTimeIntervalLength type. +type DateTimeIntervalLength = string + +const ( + DateTimeIntervalLengthDay DateTimeIntervalLength = "Day" + DateTimeIntervalLengthWeek DateTimeIntervalLength = "Week" + DateTimeIntervalLengthPeriod DateTimeIntervalLength = "Period" + DateTimeIntervalLengthMonth DateTimeIntervalLength = "Month" + DateTimeIntervalLengthQuarter DateTimeIntervalLength = "Quarter" + DateTimeIntervalLengthYear DateTimeIntervalLength = "Year" +) + +// DateTimeIntervalModifier enumerates the possible values for the DateTimeIntervalModifier type. +type DateTimeIntervalModifier = string + +const ( + DateTimeIntervalModifierLast DateTimeIntervalModifier = "Last" + DateTimeIntervalModifierThis DateTimeIntervalModifier = "This" + DateTimeIntervalModifierNext DateTimeIntervalModifier = "Next" + DateTimeIntervalModifierPast DateTimeIntervalModifier = "Past" + DateTimeIntervalModifierFuture DateTimeIntervalModifier = "Future" + DateTimeIntervalModifierAlways DateTimeIntervalModifier = "Always" +) diff --git a/modelsdk/gen/datasets/refs.go b/modelsdk/gen/datasets/refs.go new file mode 100644 index 00000000..a237cae8 --- /dev/null +++ b/modelsdk/gen/datasets/refs.go @@ -0,0 +1,13 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datasets + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("DataSets$DataSetModuleRoleAccess", []codec.RefMeta{ + {Prop: "ModuleRole", Kind: codec.RefByName, Target: "Security$ModuleRole"}, + }) +} diff --git a/modelsdk/gen/datasets/types.go b/modelsdk/gen/datasets/types.go new file mode 100644 index 00000000..cd6feaa7 --- /dev/null +++ b/modelsdk/gen/datasets/types.go @@ -0,0 +1,1013 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datasets + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// DataSet +// ──────────────────────────────────────────────────────── + +type DataSet struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + source *property.Part[element.Element] + parameters *property.PartList[element.Element] + dataSetAccess *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DataSet) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataSet) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *DataSet) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *DataSet) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *DataSet) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *DataSet) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *DataSet) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *DataSet) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Source returns the value of the source property. +func (o *DataSet) Source() element.Element { + return o.source.Get() +} + +// SetSource sets the value of the source property. +func (o *DataSet) SetSource(v element.Element) { + o.source.Set(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *DataSet) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *DataSet) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *DataSet) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// DataSetAccess returns the value of the dataSetAccess property. +func (o *DataSet) DataSetAccess() element.Element { + return o.dataSetAccess.Get() +} + +// SetDataSetAccess sets the value of the dataSetAccess property. +func (o *DataSet) SetDataSetAccess(v element.Element) { + o.dataSetAccess.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSet) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Source"); err == nil { + o.source.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "DataSetAccess"); err == nil { + o.dataSetAccess.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DataSetAccess +// ──────────────────────────────────────────────────────── + +type DataSetAccess struct { + element.Base + moduleRoleAccessList *property.PartList[element.Element] +} + +// ModuleRoleAccessListItems returns the value of the moduleRoleAccessList property. +func (o *DataSetAccess) ModuleRoleAccessListItems() []element.Element { + return o.moduleRoleAccessList.Items() +} + +// AddModuleRoleAccessList appends a child element to the moduleRoleAccessList list. +func (o *DataSetAccess) AddModuleRoleAccessList(v element.Element) { + o.moduleRoleAccessList.Append(v) +} + +// RemoveModuleRoleAccessList removes the element at the given index from the moduleRoleAccessList list. +func (o *DataSetAccess) RemoveModuleRoleAccessList(index int) { + o.moduleRoleAccessList.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetAccess) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "ModuleRoleAccessList"); err == nil { + for _, child := range children { + o.moduleRoleAccessList.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// DataSetColumn +// ──────────────────────────────────────────────────────── + +type DataSetColumn struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + columnType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DataSetColumn) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataSetColumn) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *DataSetColumn) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *DataSetColumn) SetType(v string) { + o.propType.Set(v) +} + +// ColumnType returns the value of the columnType property. +func (o *DataSetColumn) ColumnType() element.Element { + return o.columnType.Get() +} + +// SetColumnType sets the value of the columnType property. +func (o *DataSetColumn) SetColumnType(v element.Element) { + o.columnType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetColumn) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "ColumnType"); err == nil { + o.columnType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DataSetConstraintAccess +// ──────────────────────────────────────────────────────── + +type DataSetConstraintAccess struct { + element.Base + constraintText *property.Primitive[string] + enabled *property.Primitive[bool] +} + +// ConstraintText returns the value of the constraintText property. +func (o *DataSetConstraintAccess) ConstraintText() string { + return o.constraintText.Get() +} + +// SetConstraintText sets the value of the constraintText property. +func (o *DataSetConstraintAccess) SetConstraintText(v string) { + o.constraintText.Set(v) +} + +// Enabled returns the value of the enabled property. +func (o *DataSetConstraintAccess) Enabled() bool { + return o.enabled.Get() +} + +// SetEnabled sets the value of the enabled property. +func (o *DataSetConstraintAccess) SetEnabled(v bool) { + o.enabled.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetConstraintAccess) InitFromRaw(raw bson.Raw) { + o.constraintText.Init(raw) + o.enabled.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataSetParameterConstraint +// ──────────────────────────────────────────────────────── + +type DataSetParameterConstraint struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetParameterConstraint) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// DataSetDateTimeConstraint +// ──────────────────────────────────────────────────────── + +type DataSetDateTimeConstraint struct { + element.Base + modifier *property.Enum[string] + length *property.Enum[string] +} + +// Modifier returns the value of the modifier property. +func (o *DataSetDateTimeConstraint) Modifier() string { + return o.modifier.Get() +} + +// SetModifier sets the value of the modifier property. +func (o *DataSetDateTimeConstraint) SetModifier(v string) { + o.modifier.Set(v) +} + +// Length returns the value of the length property. +func (o *DataSetDateTimeConstraint) Length() string { + return o.length.Get() +} + +// SetLength sets the value of the length property. +func (o *DataSetDateTimeConstraint) SetLength(v string) { + o.length.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetDateTimeConstraint) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Modifier"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.modifier.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Length"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.length.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// DataSetModuleRoleAccess +// ──────────────────────────────────────────────────────── + +type DataSetModuleRoleAccess struct { + element.Base + parameterAccessList *property.PartList[element.Element] + moduleRole *property.ByNameRef[element.Element] +} + +// ParameterAccessListItems returns the value of the parameterAccessList property. +func (o *DataSetModuleRoleAccess) ParameterAccessListItems() []element.Element { + return o.parameterAccessList.Items() +} + +// AddParameterAccessList appends a child element to the parameterAccessList list. +func (o *DataSetModuleRoleAccess) AddParameterAccessList(v element.Element) { + o.parameterAccessList.Append(v) +} + +// RemoveParameterAccessList removes the element at the given index from the parameterAccessList list. +func (o *DataSetModuleRoleAccess) RemoveParameterAccessList(index int) { + o.parameterAccessList.Remove(index) +} + +// ModuleRoleQualifiedName returns the value of the moduleRole property. +func (o *DataSetModuleRoleAccess) ModuleRoleQualifiedName() string { + return o.moduleRole.QualifiedName() +} + +// SetModuleRoleQualifiedName sets the value of the moduleRole property. +func (o *DataSetModuleRoleAccess) SetModuleRoleQualifiedName(v string) { + o.moduleRole.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetModuleRoleAccess) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "ParameterAccessList"); err == nil { + for _, child := range children { + o.parameterAccessList.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("ModuleRole"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.moduleRole.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// DataSetNumericConstraint +// ──────────────────────────────────────────────────────── + +type DataSetNumericConstraint struct { + element.Base + begin *property.Primitive[string] + applyBegin *property.Primitive[bool] + end *property.Primitive[string] + applyEnd *property.Primitive[bool] +} + +// Begin returns the value of the begin property. +func (o *DataSetNumericConstraint) Begin() string { + return o.begin.Get() +} + +// SetBegin sets the value of the begin property. +func (o *DataSetNumericConstraint) SetBegin(v string) { + o.begin.Set(v) +} + +// ApplyBegin returns the value of the applyBegin property. +func (o *DataSetNumericConstraint) ApplyBegin() bool { + return o.applyBegin.Get() +} + +// SetApplyBegin sets the value of the applyBegin property. +func (o *DataSetNumericConstraint) SetApplyBegin(v bool) { + o.applyBegin.Set(v) +} + +// End returns the value of the end property. +func (o *DataSetNumericConstraint) End() string { + return o.end.Get() +} + +// SetEnd sets the value of the end property. +func (o *DataSetNumericConstraint) SetEnd(v string) { + o.end.Set(v) +} + +// ApplyEnd returns the value of the applyEnd property. +func (o *DataSetNumericConstraint) ApplyEnd() bool { + return o.applyEnd.Get() +} + +// SetApplyEnd sets the value of the applyEnd property. +func (o *DataSetNumericConstraint) SetApplyEnd(v bool) { + o.applyEnd.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetNumericConstraint) InitFromRaw(raw bson.Raw) { + o.begin.Init(raw) + o.applyBegin.Init(raw) + o.end.Init(raw) + o.applyEnd.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataSetObjectConstraint +// ──────────────────────────────────────────────────────── + +type DataSetObjectConstraint struct { + element.Base + name *property.Primitive[string] + constraint *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *DataSetObjectConstraint) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataSetObjectConstraint) SetName(v string) { + o.name.Set(v) +} + +// Constraint returns the value of the constraint property. +func (o *DataSetObjectConstraint) Constraint() string { + return o.constraint.Get() +} + +// SetConstraint sets the value of the constraint property. +func (o *DataSetObjectConstraint) SetConstraint(v string) { + o.constraint.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetObjectConstraint) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.constraint.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataSetParameter +// ──────────────────────────────────────────────────────── + +type DataSetParameter struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + parameterType *property.Part[element.Element] + parameterTypeIsRange *property.Primitive[bool] + constraints *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *DataSetParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataSetParameter) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *DataSetParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *DataSetParameter) SetType(v string) { + o.propType.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *DataSetParameter) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *DataSetParameter) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// ParameterTypeIsRange returns the value of the parameterTypeIsRange property. +func (o *DataSetParameter) ParameterTypeIsRange() bool { + return o.parameterTypeIsRange.Get() +} + +// SetParameterTypeIsRange sets the value of the parameterTypeIsRange property. +func (o *DataSetParameter) SetParameterTypeIsRange(v bool) { + o.parameterTypeIsRange.Set(v) +} + +// ConstraintsItems returns the value of the constraints property. +func (o *DataSetParameter) ConstraintsItems() []element.Element { + return o.constraints.Items() +} + +// AddConstraints appends a child element to the constraints list. +func (o *DataSetParameter) AddConstraints(v element.Element) { + o.constraints.Append(v) +} + +// RemoveConstraints removes the element at the given index from the constraints list. +func (o *DataSetParameter) RemoveConstraints(index int) { + o.constraints.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } + o.parameterTypeIsRange.Init(raw) + if children, err := codec.DecodeChildren(raw, "Constraints"); err == nil { + for _, child := range children { + o.constraints.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// DataSetParameterAccess +// ──────────────────────────────────────────────────────── + +type DataSetParameterAccess struct { + element.Base + parameterName *property.Primitive[string] + constraintAccessList *property.PartList[element.Element] +} + +// ParameterName returns the value of the parameterName property. +func (o *DataSetParameterAccess) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *DataSetParameterAccess) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// ConstraintAccessListItems returns the value of the constraintAccessList property. +func (o *DataSetParameterAccess) ConstraintAccessListItems() []element.Element { + return o.constraintAccessList.Items() +} + +// AddConstraintAccessList appends a child element to the constraintAccessList list. +func (o *DataSetParameterAccess) AddConstraintAccessList(v element.Element) { + o.constraintAccessList.Append(v) +} + +// RemoveConstraintAccessList removes the element at the given index from the constraintAccessList list. +func (o *DataSetParameterAccess) RemoveConstraintAccessList(index int) { + o.constraintAccessList.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetParameterAccess) InitFromRaw(raw bson.Raw) { + o.parameterName.Init(raw) + if children, err := codec.DecodeChildren(raw, "ConstraintAccessList"); err == nil { + for _, child := range children { + o.constraintAccessList.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// DataSetSource +// ──────────────────────────────────────────────────────── + +type DataSetSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSetSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// JavaDataSetSource +// ──────────────────────────────────────────────────────── + +type JavaDataSetSource struct { + element.Base + columns *property.PartList[element.Element] + useLegacyCodeGeneration *property.Primitive[bool] +} + +// ColumnsItems returns the value of the columns property. +func (o *JavaDataSetSource) ColumnsItems() []element.Element { + return o.columns.Items() +} + +// AddColumns appends a child element to the columns list. +func (o *JavaDataSetSource) AddColumns(v element.Element) { + o.columns.Append(v) +} + +// RemoveColumns removes the element at the given index from the columns list. +func (o *JavaDataSetSource) RemoveColumns(index int) { + o.columns.Remove(index) +} + +// UseLegacyCodeGeneration returns the value of the useLegacyCodeGeneration property. +func (o *JavaDataSetSource) UseLegacyCodeGeneration() bool { + return o.useLegacyCodeGeneration.Get() +} + +// SetUseLegacyCodeGeneration sets the value of the useLegacyCodeGeneration property. +func (o *JavaDataSetSource) SetUseLegacyCodeGeneration(v bool) { + o.useLegacyCodeGeneration.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaDataSetSource) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Columns"); err == nil { + for _, child := range children { + o.columns.AppendFromDecode(child) + } + } + o.useLegacyCodeGeneration.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OqlDataSetSource +// ──────────────────────────────────────────────────────── + +type OqlDataSetSource struct { + element.Base + query *property.Primitive[string] + ignoreErrorsInQuery *property.Primitive[bool] +} + +// Query returns the value of the query property. +func (o *OqlDataSetSource) Query() string { + return o.query.Get() +} + +// SetQuery sets the value of the query property. +func (o *OqlDataSetSource) SetQuery(v string) { + o.query.Set(v) +} + +// IgnoreErrorsInQuery returns the value of the ignoreErrorsInQuery property. +func (o *OqlDataSetSource) IgnoreErrorsInQuery() bool { + return o.ignoreErrorsInQuery.Get() +} + +// SetIgnoreErrorsInQuery sets the value of the ignoreErrorsInQuery property. +func (o *OqlDataSetSource) SetIgnoreErrorsInQuery(v bool) { + o.ignoreErrorsInQuery.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OqlDataSetSource) InitFromRaw(raw bson.Raw) { + o.query.Init(raw) + o.ignoreErrorsInQuery.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initDataSet creates a DataSet with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataSet() *DataSet { + o := &DataSet{} + o.SetTypeName("DataSets$DataSet") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.source = property.NewPart[element.Element]("Source") + o.source.Bind(&o.Base, 4) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 5) + o.dataSetAccess = property.NewPart[element.Element]("DataSetAccess") + o.dataSetAccess.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.source, o.parameters, o.dataSetAccess}) + return o +} + +// NewDataSet creates a new DataSet for user code. Marked dirty (bit 63 = new element). +func NewDataSet() *DataSet { + o := initDataSet() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataSetAccess creates a DataSetAccess with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataSetAccess() *DataSetAccess { + o := &DataSetAccess{} + o.SetTypeName("DataSets$DataSetAccess") + o.moduleRoleAccessList = property.NewPartList[element.Element]("ModuleRoleAccessList") + o.moduleRoleAccessList.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.moduleRoleAccessList}) + return o +} + +// NewDataSetAccess creates a new DataSetAccess for user code. Marked dirty (bit 63 = new element). +func NewDataSetAccess() *DataSetAccess { + o := initDataSetAccess() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataSetColumn creates a DataSetColumn with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataSetColumn() *DataSetColumn { + o := &DataSetColumn{} + o.SetTypeName("DataSets$DataSetColumn") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 1) + o.columnType = property.NewPart[element.Element]("ColumnType") + o.columnType.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.propType, o.columnType}) + return o +} + +// NewDataSetColumn creates a new DataSetColumn for user code. Marked dirty (bit 63 = new element). +func NewDataSetColumn() *DataSetColumn { + o := initDataSetColumn() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataSetConstraintAccess creates a DataSetConstraintAccess with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataSetConstraintAccess() *DataSetConstraintAccess { + o := &DataSetConstraintAccess{} + o.SetTypeName("DataSets$DataSetConstraintAccess") + o.constraintText = property.NewPrimitive[string]("ConstraintText", property.DecodeString) + o.constraintText.Bind(&o.Base, 0) + o.enabled = property.NewPrimitive[bool]("Enabled", property.DecodeBool) + o.enabled.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.constraintText, o.enabled}) + return o +} + +// NewDataSetConstraintAccess creates a new DataSetConstraintAccess for user code. Marked dirty (bit 63 = new element). +func NewDataSetConstraintAccess() *DataSetConstraintAccess { + o := initDataSetConstraintAccess() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataSetDateTimeConstraint creates a DataSetDateTimeConstraint with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataSetDateTimeConstraint() *DataSetDateTimeConstraint { + o := &DataSetDateTimeConstraint{} + o.SetTypeName("DataSets$DataSetDateTimeConstraint") + o.modifier = property.NewEnum[string]("Modifier") + o.modifier.Bind(&o.Base, 0) + o.length = property.NewEnum[string]("Length") + o.length.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.modifier, o.length}) + return o +} + +// NewDataSetDateTimeConstraint creates a new DataSetDateTimeConstraint for user code. Marked dirty (bit 63 = new element). +func NewDataSetDateTimeConstraint() *DataSetDateTimeConstraint { + o := initDataSetDateTimeConstraint() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataSetModuleRoleAccess creates a DataSetModuleRoleAccess with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataSetModuleRoleAccess() *DataSetModuleRoleAccess { + o := &DataSetModuleRoleAccess{} + o.SetTypeName("DataSets$DataSetModuleRoleAccess") + o.parameterAccessList = property.NewPartList[element.Element]("ParameterAccessList") + o.parameterAccessList.Bind(&o.Base, 0) + o.moduleRole = property.NewByNameRef[element.Element]("ModuleRole", "Security$ModuleRole") + o.moduleRole.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameterAccessList, o.moduleRole}) + return o +} + +// NewDataSetModuleRoleAccess creates a new DataSetModuleRoleAccess for user code. Marked dirty (bit 63 = new element). +func NewDataSetModuleRoleAccess() *DataSetModuleRoleAccess { + o := initDataSetModuleRoleAccess() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataSetNumericConstraint creates a DataSetNumericConstraint with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataSetNumericConstraint() *DataSetNumericConstraint { + o := &DataSetNumericConstraint{} + o.SetTypeName("DataSets$DataSetNumericConstraint") + o.begin = property.NewPrimitive[string]("Begin", property.DecodeString) + o.begin.Bind(&o.Base, 0) + o.applyBegin = property.NewPrimitive[bool]("ApplyBegin", property.DecodeBool) + o.applyBegin.Bind(&o.Base, 1) + o.end = property.NewPrimitive[string]("End", property.DecodeString) + o.end.Bind(&o.Base, 2) + o.applyEnd = property.NewPrimitive[bool]("ApplyEnd", property.DecodeBool) + o.applyEnd.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.begin, o.applyBegin, o.end, o.applyEnd}) + return o +} + +// NewDataSetNumericConstraint creates a new DataSetNumericConstraint for user code. Marked dirty (bit 63 = new element). +func NewDataSetNumericConstraint() *DataSetNumericConstraint { + o := initDataSetNumericConstraint() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataSetObjectConstraint creates a DataSetObjectConstraint with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataSetObjectConstraint() *DataSetObjectConstraint { + o := &DataSetObjectConstraint{} + o.SetTypeName("DataSets$DataSetObjectConstraint") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.constraint = property.NewPrimitive[string]("Constraint", property.DecodeString) + o.constraint.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.constraint}) + return o +} + +// NewDataSetObjectConstraint creates a new DataSetObjectConstraint for user code. Marked dirty (bit 63 = new element). +func NewDataSetObjectConstraint() *DataSetObjectConstraint { + o := initDataSetObjectConstraint() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataSetParameter creates a DataSetParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataSetParameter() *DataSetParameter { + o := &DataSetParameter{} + o.SetTypeName("DataSets$DataSetParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 1) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 2) + o.parameterTypeIsRange = property.NewPrimitive[bool]("ParameterTypeIsRange", property.DecodeBool) + o.parameterTypeIsRange.Bind(&o.Base, 3) + o.constraints = property.NewPartList[element.Element]("Constraints") + o.constraints.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.propType, o.parameterType, o.parameterTypeIsRange, o.constraints}) + return o +} + +// NewDataSetParameter creates a new DataSetParameter for user code. Marked dirty (bit 63 = new element). +func NewDataSetParameter() *DataSetParameter { + o := initDataSetParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataSetParameterAccess creates a DataSetParameterAccess with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataSetParameterAccess() *DataSetParameterAccess { + o := &DataSetParameterAccess{} + o.SetTypeName("DataSets$DataSetParameterAccess") + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 0) + o.constraintAccessList = property.NewPartList[element.Element]("ConstraintAccessList") + o.constraintAccessList.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameterName, o.constraintAccessList}) + return o +} + +// NewDataSetParameterAccess creates a new DataSetParameterAccess for user code. Marked dirty (bit 63 = new element). +func NewDataSetParameterAccess() *DataSetParameterAccess { + o := initDataSetParameterAccess() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJavaDataSetSource creates a JavaDataSetSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJavaDataSetSource() *JavaDataSetSource { + o := &JavaDataSetSource{} + o.SetTypeName("DataSets$JavaDataSetSource") + o.columns = property.NewPartList[element.Element]("Columns") + o.columns.Bind(&o.Base, 0) + o.useLegacyCodeGeneration = property.NewPrimitive[bool]("UseLegacyCodeGeneration", property.DecodeBool) + o.useLegacyCodeGeneration.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.columns, o.useLegacyCodeGeneration}) + return o +} + +// NewJavaDataSetSource creates a new JavaDataSetSource for user code. Marked dirty (bit 63 = new element). +func NewJavaDataSetSource() *JavaDataSetSource { + o := initJavaDataSetSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOqlDataSetSource creates a OqlDataSetSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOqlDataSetSource() *OqlDataSetSource { + o := &OqlDataSetSource{} + o.SetTypeName("DataSets$OqlDataSetSource") + o.query = property.NewPrimitive[string]("Query", property.DecodeString) + o.query.Bind(&o.Base, 0) + o.ignoreErrorsInQuery = property.NewPrimitive[bool]("IgnoreErrorsInQuery", property.DecodeBool) + o.ignoreErrorsInQuery.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.query, o.ignoreErrorsInQuery}) + return o +} + +// NewOqlDataSetSource creates a new OqlDataSetSource for user code. Marked dirty (bit 63 = new element). +func NewOqlDataSetSource() *OqlDataSetSource { + o := initOqlDataSetSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("DataSets$DataSet", func() element.Element { + return initDataSet() + }) + codec.DefaultRegistry.Register("DataSets$DataSetAccess", func() element.Element { + return initDataSetAccess() + }) + codec.DefaultRegistry.Register("DataSets$DataSetColumn", func() element.Element { + return initDataSetColumn() + }) + codec.DefaultRegistry.Register("DataSets$DataSetConstraintAccess", func() element.Element { + return initDataSetConstraintAccess() + }) + codec.DefaultRegistry.Register("DataSets$DataSetDateTimeConstraint", func() element.Element { + return initDataSetDateTimeConstraint() + }) + codec.DefaultRegistry.Register("DataSets$DataSetModuleRoleAccess", func() element.Element { + return initDataSetModuleRoleAccess() + }) + codec.DefaultRegistry.Register("DataSets$DataSetNumericConstraint", func() element.Element { + return initDataSetNumericConstraint() + }) + codec.DefaultRegistry.Register("DataSets$DataSetObjectConstraint", func() element.Element { + return initDataSetObjectConstraint() + }) + codec.DefaultRegistry.Register("DataSets$DataSetParameter", func() element.Element { + return initDataSetParameter() + }) + codec.DefaultRegistry.Register("DataSets$DataSetParameterAccess", func() element.Element { + return initDataSetParameterAccess() + }) + codec.DefaultRegistry.Register("DataSets$JavaDataSetSource", func() element.Element { + return initJavaDataSetSource() + }) + codec.DefaultRegistry.Register("DataSets$OqlDataSetSource", func() element.Element { + return initOqlDataSetSource() + }) +} diff --git a/modelsdk/gen/datasets/version.go b/modelsdk/gen/datasets/version.go new file mode 100644 index 00000000..ab0bea95 --- /dev/null +++ b/modelsdk/gen/datasets/version.go @@ -0,0 +1,37 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datasets + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "DataSets$DataSet": { + Properties: map[string]version.PropertyVersionInfo{ + "dataSetAccess": {Required: true}, + "parameters": {Public: true}, + "source": {Required: true}, + }, + }, + "DataSets$DataSetColumn": { + Properties: map[string]version.PropertyVersionInfo{ + "columnType": {Introduced: "7.9.0", Required: true}, + "type": {Deleted: "7.9.0"}, + }, + }, + "DataSets$DataSetParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "parameterType": {Introduced: "7.9.0", Required: true}, + "parameterTypeIsRange": {Introduced: "7.9.0"}, + "type": {Deleted: "7.9.0"}, + }, + }, + "DataSets$JavaDataSetSource": { + Properties: map[string]version.PropertyVersionInfo{ + "useLegacyCodeGeneration": {Introduced: "8.0.0", Deleted: "9.0.3"}, + }, + }, +} diff --git a/modelsdk/gen/datatransformers/enums.go b/modelsdk/gen/datatransformers/enums.go new file mode 100644 index 00000000..f90b84eb --- /dev/null +++ b/modelsdk/gen/datatransformers/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datatransformers diff --git a/modelsdk/gen/datatransformers/refs.go b/modelsdk/gen/datatransformers/refs.go new file mode 100644 index 00000000..e35c562a --- /dev/null +++ b/modelsdk/gen/datatransformers/refs.go @@ -0,0 +1,20 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datatransformers + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("DataTransformers$DataTransformer", []codec.RefMeta{ + {Prop: "RootElement", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("DataTransformers$Step", []codec.RefMeta{ + {Prop: "InputElement", Kind: codec.RefById, Target: ""}, + {Prop: "OutputElement", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("DataTransformers$StructureAttribute", []codec.RefMeta{ + {Prop: "Value", Kind: codec.RefById, Target: ""}, + }) +} diff --git a/modelsdk/gen/datatransformers/types.go b/modelsdk/gen/datatransformers/types.go new file mode 100644 index 00000000..41ac4721 --- /dev/null +++ b/modelsdk/gen/datatransformers/types.go @@ -0,0 +1,838 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datatransformers + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// StructureValueType +// ──────────────────────────────────────────────────────── + +type StructureValueType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StructureValueType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BooleanValueType +// ──────────────────────────────────────────────────────── + +type BooleanValueType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BooleanValueType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// DataTransformer +// ──────────────────────────────────────────────────────── + +type DataTransformer struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + elements *property.PartList[element.Element] + rootElement *property.ByIdRef[element.Element] + steps *property.PartList[element.Element] + source *property.Part[element.Element] + sourceJson *property.Primitive[string] + sourceType *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *DataTransformer) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataTransformer) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *DataTransformer) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *DataTransformer) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *DataTransformer) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *DataTransformer) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *DataTransformer) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *DataTransformer) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ElementsItems returns the value of the elements property. +func (o *DataTransformer) ElementsItems() []element.Element { + return o.elements.Items() +} + +// AddElements appends a child element to the elements list. +func (o *DataTransformer) AddElements(v element.Element) { + o.elements.Append(v) +} + +// RemoveElements removes the element at the given index from the elements list. +func (o *DataTransformer) RemoveElements(index int) { + o.elements.Remove(index) +} + +// RootElementRefID returns the value of the rootElement property. +func (o *DataTransformer) RootElementRefID() element.ID { + return o.rootElement.RefID() +} + +// SetRootElementID sets the value of the rootElement property. +func (o *DataTransformer) SetRootElementID(v element.ID) { + o.rootElement.SetID(v) +} + +// StepsItems returns the value of the steps property. +func (o *DataTransformer) StepsItems() []element.Element { + return o.steps.Items() +} + +// AddSteps appends a child element to the steps list. +func (o *DataTransformer) AddSteps(v element.Element) { + o.steps.Append(v) +} + +// RemoveSteps removes the element at the given index from the steps list. +func (o *DataTransformer) RemoveSteps(index int) { + o.steps.Remove(index) +} + +// Source returns the value of the source property. +func (o *DataTransformer) Source() element.Element { + return o.source.Get() +} + +// SetSource sets the value of the source property. +func (o *DataTransformer) SetSource(v element.Element) { + o.source.Set(v) +} + +// SourceJson returns the value of the sourceJson property. +func (o *DataTransformer) SourceJson() string { + return o.sourceJson.Get() +} + +// SetSourceJson sets the value of the sourceJson property. +func (o *DataTransformer) SetSourceJson(v string) { + o.sourceJson.Set(v) +} + +// SourceType returns the value of the sourceType property. +func (o *DataTransformer) SourceType() string { + return o.sourceType.Get() +} + +// SetSourceType sets the value of the sourceType property. +func (o *DataTransformer) SetSourceType(v string) { + o.sourceType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataTransformer) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Elements"); err == nil { + for _, child := range children { + o.elements.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("RootElement"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.rootElement.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.rootElement.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + if children, err := codec.DecodeChildren(raw, "Steps"); err == nil { + for _, child := range children { + o.steps.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Source"); err == nil { + o.source.SetFromDecode(child) + } + o.sourceJson.Init(raw) + o.sourceType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DateTimeValueType +// ──────────────────────────────────────────────────────── + +type DateTimeValueType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DateTimeValueType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// DecimalValueType +// ──────────────────────────────────────────────────────── + +type DecimalValueType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DecimalValueType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// TransformerAction +// ──────────────────────────────────────────────────────── + +type TransformerAction struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TransformerAction) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// JsltAction +// ──────────────────────────────────────────────────────── + +type JsltAction struct { + element.Base + jslt *property.Primitive[string] +} + +// Jslt returns the value of the jslt property. +func (o *JsltAction) Jslt() string { + return o.jslt.Get() +} + +// SetJslt sets the value of the jslt property. +func (o *JsltAction) SetJslt(v string) { + o.jslt.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JsltAction) InitFromRaw(raw bson.Raw) { + o.jslt.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Source +// ──────────────────────────────────────────────────────── + +type Source struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Source) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// JsonSource +// ──────────────────────────────────────────────────────── + +type JsonSource struct { + element.Base + content *property.Primitive[string] +} + +// Content returns the value of the content property. +func (o *JsonSource) Content() string { + return o.content.Get() +} + +// SetContent sets the value of the content property. +func (o *JsonSource) SetContent(v string) { + o.content.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JsonSource) InitFromRaw(raw bson.Raw) { + o.content.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LongValueType +// ──────────────────────────────────────────────────────── + +type LongValueType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LongValueType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Step +// ──────────────────────────────────────────────────────── + +type Step struct { + element.Base + action *property.Part[element.Element] + inputElement *property.ByIdRef[element.Element] + outputElement *property.ByIdRef[element.Element] + technology *property.Primitive[string] + expression *property.Primitive[string] +} + +// Action returns the value of the action property. +func (o *Step) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *Step) SetAction(v element.Element) { + o.action.Set(v) +} + +// InputElementRefID returns the value of the inputElement property. +func (o *Step) InputElementRefID() element.ID { + return o.inputElement.RefID() +} + +// SetInputElementID sets the value of the inputElement property. +func (o *Step) SetInputElementID(v element.ID) { + o.inputElement.SetID(v) +} + +// OutputElementRefID returns the value of the outputElement property. +func (o *Step) OutputElementRefID() element.ID { + return o.outputElement.RefID() +} + +// SetOutputElementID sets the value of the outputElement property. +func (o *Step) SetOutputElementID(v element.ID) { + o.outputElement.SetID(v) +} + +// Technology returns the value of the technology property. +func (o *Step) Technology() string { + return o.technology.Get() +} + +// SetTechnology sets the value of the technology property. +func (o *Step) SetTechnology(v string) { + o.technology.Set(v) +} + +// Expression returns the value of the expression property. +func (o *Step) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *Step) SetExpression(v string) { + o.expression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Step) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } + if val, err := raw.LookupErr("InputElement"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.inputElement.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.inputElement.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + if val, err := raw.LookupErr("OutputElement"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.outputElement.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.outputElement.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.technology.Init(raw) + o.expression.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// StringValueType +// ──────────────────────────────────────────────────────── + +type StringValueType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringValueType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// StructureElement +// ──────────────────────────────────────────────────────── + +type StructureElement struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StructureElement) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// StructureAttribute +// ──────────────────────────────────────────────────────── + +type StructureAttribute struct { + element.Base + name *property.Primitive[string] + value *property.ByIdRef[element.Element] +} + +// Name returns the value of the name property. +func (o *StructureAttribute) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *StructureAttribute) SetName(v string) { + o.name.Set(v) +} + +// ValueRefID returns the value of the value property. +func (o *StructureAttribute) ValueRefID() element.ID { + return o.value.RefID() +} + +// SetValueID sets the value of the value property. +func (o *StructureAttribute) SetValueID(v element.ID) { + o.value.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StructureAttribute) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if val, err := raw.LookupErr("Value"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.value.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.value.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// StructureObject +// ──────────────────────────────────────────────────────── + +type StructureObject struct { + element.Base + attributes *property.PartList[element.Element] +} + +// AttributesItems returns the value of the attributes property. +func (o *StructureObject) AttributesItems() []element.Element { + return o.attributes.Items() +} + +// AddAttributes appends a child element to the attributes list. +func (o *StructureObject) AddAttributes(v element.Element) { + o.attributes.Append(v) +} + +// RemoveAttributes removes the element at the given index from the attributes list. +func (o *StructureObject) RemoveAttributes(index int) { + o.attributes.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StructureObject) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Attributes"); err == nil { + for _, child := range children { + o.attributes.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// StructureValue +// ──────────────────────────────────────────────────────── + +type StructureValue struct { + element.Base + propType *property.Part[element.Element] +} + +// Type returns the value of the type property. +func (o *StructureValue) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *StructureValue) SetType(v element.Element) { + o.propType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StructureValue) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initBooleanValueType creates a BooleanValueType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBooleanValueType() *BooleanValueType { + o := &BooleanValueType{} + o.SetTypeName("DataTransformers$BooleanValueType") + o.SetProperties([]element.Property{}) + return o +} + +// NewBooleanValueType creates a new BooleanValueType for user code. Marked dirty (bit 63 = new element). +func NewBooleanValueType() *BooleanValueType { + o := initBooleanValueType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataTransformer creates a DataTransformer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataTransformer() *DataTransformer { + o := &DataTransformer{} + o.SetTypeName("DataTransformers$DataTransformer") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.elements = property.NewPartList[element.Element]("Elements") + o.elements.Bind(&o.Base, 4) + o.rootElement = property.NewByIdRef[element.Element]("RootElement") + o.rootElement.Bind(&o.Base, 5) + o.steps = property.NewPartList[element.Element]("Steps") + o.steps.Bind(&o.Base, 6) + o.source = property.NewPart[element.Element]("Source") + o.source.Bind(&o.Base, 7) + o.sourceJson = property.NewPrimitive[string]("SourceJson", property.DecodeString) + o.sourceJson.Bind(&o.Base, 8) + o.sourceType = property.NewPrimitive[string]("SourceType", property.DecodeString) + o.sourceType.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.elements, o.rootElement, o.steps, o.source, o.sourceJson, o.sourceType}) + return o +} + +// NewDataTransformer creates a new DataTransformer for user code. Marked dirty (bit 63 = new element). +func NewDataTransformer() *DataTransformer { + o := initDataTransformer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDateTimeValueType creates a DateTimeValueType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDateTimeValueType() *DateTimeValueType { + o := &DateTimeValueType{} + o.SetTypeName("DataTransformers$DateTimeValueType") + o.SetProperties([]element.Property{}) + return o +} + +// NewDateTimeValueType creates a new DateTimeValueType for user code. Marked dirty (bit 63 = new element). +func NewDateTimeValueType() *DateTimeValueType { + o := initDateTimeValueType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDecimalValueType creates a DecimalValueType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDecimalValueType() *DecimalValueType { + o := &DecimalValueType{} + o.SetTypeName("DataTransformers$DecimalValueType") + o.SetProperties([]element.Property{}) + return o +} + +// NewDecimalValueType creates a new DecimalValueType for user code. Marked dirty (bit 63 = new element). +func NewDecimalValueType() *DecimalValueType { + o := initDecimalValueType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJsltAction creates a JsltAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJsltAction() *JsltAction { + o := &JsltAction{} + o.SetTypeName("DataTransformers$JsltAction") + o.jslt = property.NewPrimitive[string]("Jslt", property.DecodeString) + o.jslt.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.jslt}) + return o +} + +// NewJsltAction creates a new JsltAction for user code. Marked dirty (bit 63 = new element). +func NewJsltAction() *JsltAction { + o := initJsltAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJsonSource creates a JsonSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJsonSource() *JsonSource { + o := &JsonSource{} + o.SetTypeName("DataTransformers$JsonSource") + o.content = property.NewPrimitive[string]("Content", property.DecodeString) + o.content.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.content}) + return o +} + +// NewJsonSource creates a new JsonSource for user code. Marked dirty (bit 63 = new element). +func NewJsonSource() *JsonSource { + o := initJsonSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLongValueType creates a LongValueType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLongValueType() *LongValueType { + o := &LongValueType{} + o.SetTypeName("DataTransformers$LongValueType") + o.SetProperties([]element.Property{}) + return o +} + +// NewLongValueType creates a new LongValueType for user code. Marked dirty (bit 63 = new element). +func NewLongValueType() *LongValueType { + o := initLongValueType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStep creates a Step with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStep() *Step { + o := &Step{} + o.SetTypeName("DataTransformers$Step") + o.action = property.NewPart[element.Element]("Action") + o.action.Bind(&o.Base, 0) + o.inputElement = property.NewByIdRef[element.Element]("InputElement") + o.inputElement.Bind(&o.Base, 1) + o.outputElement = property.NewByIdRef[element.Element]("OutputElement") + o.outputElement.Bind(&o.Base, 2) + o.technology = property.NewPrimitive[string]("Technology", property.DecodeString) + o.technology.Bind(&o.Base, 3) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.action, o.inputElement, o.outputElement, o.technology, o.expression}) + return o +} + +// NewStep creates a new Step for user code. Marked dirty (bit 63 = new element). +func NewStep() *Step { + o := initStep() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringValueType creates a StringValueType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringValueType() *StringValueType { + o := &StringValueType{} + o.SetTypeName("DataTransformers$StringValueType") + o.SetProperties([]element.Property{}) + return o +} + +// NewStringValueType creates a new StringValueType for user code. Marked dirty (bit 63 = new element). +func NewStringValueType() *StringValueType { + o := initStringValueType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStructureAttribute creates a StructureAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStructureAttribute() *StructureAttribute { + o := &StructureAttribute{} + o.SetTypeName("DataTransformers$StructureAttribute") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.value = property.NewByIdRef[element.Element]("Value") + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.value}) + return o +} + +// NewStructureAttribute creates a new StructureAttribute for user code. Marked dirty (bit 63 = new element). +func NewStructureAttribute() *StructureAttribute { + o := initStructureAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStructureObject creates a StructureObject with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStructureObject() *StructureObject { + o := &StructureObject{} + o.SetTypeName("DataTransformers$StructureObject") + o.attributes = property.NewPartList[element.Element]("Attributes") + o.attributes.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.attributes}) + return o +} + +// NewStructureObject creates a new StructureObject for user code. Marked dirty (bit 63 = new element). +func NewStructureObject() *StructureObject { + o := initStructureObject() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStructureValue creates a StructureValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStructureValue() *StructureValue { + o := &StructureValue{} + o.SetTypeName("DataTransformers$StructureValue") + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.propType}) + return o +} + +// NewStructureValue creates a new StructureValue for user code. Marked dirty (bit 63 = new element). +func NewStructureValue() *StructureValue { + o := initStructureValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("DataTransformers$BooleanValueType", func() element.Element { + return initBooleanValueType() + }) + codec.DefaultRegistry.Register("DataTransformers$DataTransformer", func() element.Element { + return initDataTransformer() + }) + codec.DefaultRegistry.Register("DataTransformers$DateTimeValueType", func() element.Element { + return initDateTimeValueType() + }) + codec.DefaultRegistry.Register("DataTransformers$DecimalValueType", func() element.Element { + return initDecimalValueType() + }) + codec.DefaultRegistry.Register("DataTransformers$JsltAction", func() element.Element { + return initJsltAction() + }) + codec.DefaultRegistry.Register("DataTransformers$JsonSource", func() element.Element { + return initJsonSource() + }) + codec.DefaultRegistry.Register("DataTransformers$LongValueType", func() element.Element { + return initLongValueType() + }) + codec.DefaultRegistry.Register("DataTransformers$Step", func() element.Element { + return initStep() + }) + codec.DefaultRegistry.Register("DataTransformers$StringValueType", func() element.Element { + return initStringValueType() + }) + codec.DefaultRegistry.Register("DataTransformers$StructureAttribute", func() element.Element { + return initStructureAttribute() + }) + codec.DefaultRegistry.Register("DataTransformers$StructureObject", func() element.Element { + return initStructureObject() + }) + codec.DefaultRegistry.Register("DataTransformers$StructureValue", func() element.Element { + return initStructureValue() + }) +} diff --git a/modelsdk/gen/datatransformers/version.go b/modelsdk/gen/datatransformers/version.go new file mode 100644 index 00000000..b5f43aea --- /dev/null +++ b/modelsdk/gen/datatransformers/version.go @@ -0,0 +1,52 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datatransformers + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "DataTransformers$DataTransformer": { + Properties: map[string]version.PropertyVersionInfo{ + "elements": {Public: true}, + "rootElement": {Public: true}, + "source": {Public: true}, + "steps": {Public: true}, + }, + }, + "DataTransformers$JsltAction": { + Properties: map[string]version.PropertyVersionInfo{ + "jslt": {Public: true}, + }, + }, + "DataTransformers$JsonSource": { + Properties: map[string]version.PropertyVersionInfo{ + "content": {Public: true}, + }, + }, + "DataTransformers$Step": { + Properties: map[string]version.PropertyVersionInfo{ + "action": {Required: true, Public: true}, + "inputElement": {Required: true, Public: true}, + "outputElement": {Required: true, Public: true}, + }, + }, + "DataTransformers$StructureAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "value": {Required: true, Public: true}, + }, + }, + "DataTransformers$StructureObject": { + Properties: map[string]version.PropertyVersionInfo{ + "attributes": {Public: true}, + }, + }, + "DataTransformers$StructureValue": { + Properties: map[string]version.PropertyVersionInfo{ + "type": {Required: true, Public: true}, + }, + }, +} diff --git a/modelsdk/gen/datatypes/enums.go b/modelsdk/gen/datatypes/enums.go new file mode 100644 index 00000000..7f44c37d --- /dev/null +++ b/modelsdk/gen/datatypes/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datatypes diff --git a/modelsdk/gen/datatypes/refs.go b/modelsdk/gen/datatypes/refs.go new file mode 100644 index 00000000..0a7fee11 --- /dev/null +++ b/modelsdk/gen/datatypes/refs.go @@ -0,0 +1,22 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datatypes + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("DataTypes$EntityType", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DataTypes$EnumerationType", []codec.RefMeta{ + {Prop: "Enumeration", Kind: codec.RefByName, Target: "Enumerations$Enumeration"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DataTypes$ListType", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DataTypes$ObjectType", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) +} diff --git a/modelsdk/gen/datatypes/types.go b/modelsdk/gen/datatypes/types.go new file mode 100644 index 00000000..0ec971ba --- /dev/null +++ b/modelsdk/gen/datatypes/types.go @@ -0,0 +1,563 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datatypes + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// DataType +// ──────────────────────────────────────────────────────── + +type DataType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BinaryType +// ──────────────────────────────────────────────────────── + +type BinaryType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BinaryType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BooleanType +// ──────────────────────────────────────────────────────── + +type BooleanType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BooleanType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// DateTimeType +// ──────────────────────────────────────────────────────── + +type DateTimeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DateTimeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// DecimalType +// ──────────────────────────────────────────────────────── + +type DecimalType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DecimalType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EmptyType +// ──────────────────────────────────────────────────────── + +type EmptyType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EmptyType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EntityType +// ──────────────────────────────────────────────────────── + +type EntityType struct { + element.Base + entity *property.ByNameRef[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *EntityType) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *EntityType) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// EnumerationType +// ──────────────────────────────────────────────────────── + +type EnumerationType struct { + element.Base + enumeration *property.ByNameRef[element.Element] +} + +// EnumerationQualifiedName returns the value of the enumeration property. +func (o *EnumerationType) EnumerationQualifiedName() string { + return o.enumeration.QualifiedName() +} + +// SetEnumerationQualifiedName sets the value of the enumeration property. +func (o *EnumerationType) SetEnumerationQualifiedName(v string) { + o.enumeration.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EnumerationType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Enumeration"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.enumeration.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// FloatType +// ──────────────────────────────────────────────────────── + +type FloatType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FloatType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// IntegerType +// ──────────────────────────────────────────────────────── + +type IntegerType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IntegerType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ListType +// ──────────────────────────────────────────────────────── + +type ListType struct { + element.Base + entity *property.ByNameRef[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ListType) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ListType) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ObjectType +// ──────────────────────────────────────────────────────── + +type ObjectType struct { + element.Base + entity *property.ByNameRef[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ObjectType) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ObjectType) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ObjectType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// StringType +// ──────────────────────────────────────────────────────── + +type StringType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// UnknownType +// ──────────────────────────────────────────────────────── + +type UnknownType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UnknownType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// VoidType +// ──────────────────────────────────────────────────────── + +type VoidType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VoidType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initBinaryType creates a BinaryType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBinaryType() *BinaryType { + o := &BinaryType{} + o.SetTypeName("DataTypes$BinaryType") + o.SetProperties([]element.Property{}) + return o +} + +// NewBinaryType creates a new BinaryType for user code. Marked dirty (bit 63 = new element). +func NewBinaryType() *BinaryType { + o := initBinaryType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBooleanType creates a BooleanType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBooleanType() *BooleanType { + o := &BooleanType{} + o.SetTypeName("DataTypes$BooleanType") + o.SetProperties([]element.Property{}) + return o +} + +// NewBooleanType creates a new BooleanType for user code. Marked dirty (bit 63 = new element). +func NewBooleanType() *BooleanType { + o := initBooleanType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDateTimeType creates a DateTimeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDateTimeType() *DateTimeType { + o := &DateTimeType{} + o.SetTypeName("DataTypes$DateTimeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewDateTimeType creates a new DateTimeType for user code. Marked dirty (bit 63 = new element). +func NewDateTimeType() *DateTimeType { + o := initDateTimeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDecimalType creates a DecimalType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDecimalType() *DecimalType { + o := &DecimalType{} + o.SetTypeName("DataTypes$DecimalType") + o.SetProperties([]element.Property{}) + return o +} + +// NewDecimalType creates a new DecimalType for user code. Marked dirty (bit 63 = new element). +func NewDecimalType() *DecimalType { + o := initDecimalType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEmptyType creates a EmptyType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEmptyType() *EmptyType { + o := &EmptyType{} + o.SetTypeName("DataTypes$EmptyType") + o.SetProperties([]element.Property{}) + return o +} + +// NewEmptyType creates a new EmptyType for user code. Marked dirty (bit 63 = new element). +func NewEmptyType() *EmptyType { + o := initEmptyType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEnumerationType creates a EnumerationType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEnumerationType() *EnumerationType { + o := &EnumerationType{} + o.SetTypeName("DataTypes$EnumerationType") + o.enumeration = property.NewByNameRef[element.Element]("Enumeration", "Enumerations$Enumeration") + o.enumeration.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.enumeration}) + return o +} + +// NewEnumerationType creates a new EnumerationType for user code. Marked dirty (bit 63 = new element). +func NewEnumerationType() *EnumerationType { + o := initEnumerationType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFloatType creates a FloatType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFloatType() *FloatType { + o := &FloatType{} + o.SetTypeName("DataTypes$FloatType") + o.SetProperties([]element.Property{}) + return o +} + +// NewFloatType creates a new FloatType for user code. Marked dirty (bit 63 = new element). +func NewFloatType() *FloatType { + o := initFloatType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIntegerType creates a IntegerType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIntegerType() *IntegerType { + o := &IntegerType{} + o.SetTypeName("DataTypes$IntegerType") + o.SetProperties([]element.Property{}) + return o +} + +// NewIntegerType creates a new IntegerType for user code. Marked dirty (bit 63 = new element). +func NewIntegerType() *IntegerType { + o := initIntegerType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListType creates a ListType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListType() *ListType { + o := &ListType{} + o.SetTypeName("DataTypes$ListType") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.entity}) + return o +} + +// NewListType creates a new ListType for user code. Marked dirty (bit 63 = new element). +func NewListType() *ListType { + o := initListType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initObjectType creates a ObjectType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initObjectType() *ObjectType { + o := &ObjectType{} + o.SetTypeName("DataTypes$ObjectType") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.entity}) + return o +} + +// NewObjectType creates a new ObjectType for user code. Marked dirty (bit 63 = new element). +func NewObjectType() *ObjectType { + o := initObjectType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringType creates a StringType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringType() *StringType { + o := &StringType{} + o.SetTypeName("DataTypes$StringType") + o.SetProperties([]element.Property{}) + return o +} + +// NewStringType creates a new StringType for user code. Marked dirty (bit 63 = new element). +func NewStringType() *StringType { + o := initStringType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUnknownType creates a UnknownType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUnknownType() *UnknownType { + o := &UnknownType{} + o.SetTypeName("DataTypes$UnknownType") + o.SetProperties([]element.Property{}) + return o +} + +// NewUnknownType creates a new UnknownType for user code. Marked dirty (bit 63 = new element). +func NewUnknownType() *UnknownType { + o := initUnknownType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initVoidType creates a VoidType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initVoidType() *VoidType { + o := &VoidType{} + o.SetTypeName("DataTypes$VoidType") + o.SetProperties([]element.Property{}) + return o +} + +// NewVoidType creates a new VoidType for user code. Marked dirty (bit 63 = new element). +func NewVoidType() *VoidType { + o := initVoidType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("DataTypes$BinaryType", func() element.Element { + return initBinaryType() + }) + codec.DefaultRegistry.Register("DataTypes$BooleanType", func() element.Element { + return initBooleanType() + }) + codec.DefaultRegistry.Register("DataTypes$DateTimeType", func() element.Element { + return initDateTimeType() + }) + codec.DefaultRegistry.Register("DataTypes$DecimalType", func() element.Element { + return initDecimalType() + }) + codec.DefaultRegistry.Register("DataTypes$EmptyType", func() element.Element { + return initEmptyType() + }) + codec.DefaultRegistry.Register("DataTypes$EnumerationType", func() element.Element { + return initEnumerationType() + }) + codec.DefaultRegistry.Register("DataTypes$FloatType", func() element.Element { + return initFloatType() + }) + codec.DefaultRegistry.Register("DataTypes$IntegerType", func() element.Element { + return initIntegerType() + }) + codec.DefaultRegistry.Register("DataTypes$ListType", func() element.Element { + return initListType() + }) + codec.DefaultRegistry.Register("DataTypes$ObjectType", func() element.Element { + return initObjectType() + }) + codec.DefaultRegistry.Register("DataTypes$StringType", func() element.Element { + return initStringType() + }) + codec.DefaultRegistry.Register("DataTypes$UnknownType", func() element.Element { + return initUnknownType() + }) + codec.DefaultRegistry.Register("DataTypes$VoidType", func() element.Element { + return initVoidType() + }) +} diff --git a/modelsdk/gen/datatypes/version.go b/modelsdk/gen/datatypes/version.go new file mode 100644 index 00000000..c1d1dbc7 --- /dev/null +++ b/modelsdk/gen/datatypes/version.go @@ -0,0 +1,21 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package datatypes + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "DataTypes$EntityType": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true, Public: true}, + }, + }, + "DataTypes$EnumerationType": { + Properties: map[string]version.PropertyVersionInfo{ + "enumeration": {Required: true, Public: true}, + }, + }, +} diff --git a/modelsdk/gen/documenttemplates/enums.go b/modelsdk/gen/documenttemplates/enums.go new file mode 100644 index 00000000..e7127fe6 --- /dev/null +++ b/modelsdk/gen/documenttemplates/enums.go @@ -0,0 +1,35 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package documenttemplates + +// BorderStyle enumerates the possible values for the BorderStyle type. +type BorderStyle = string + +const ( + BorderStyleNone BorderStyle = "None" + BorderStyleDotted BorderStyle = "Dotted" + BorderStyleDashed BorderStyle = "Dashed" + BorderStyleSolid BorderStyle = "Solid" +) + +// FontFamily enumerates the possible values for the FontFamily type. +type FontFamily = string + +const ( + FontFamilyCourier FontFamily = "Courier" + FontFamilyTahoma FontFamily = "Tahoma" + FontFamilyTimes FontFamily = "Times" + FontFamilyHelvetica FontFamily = "Helvetica" + FontFamilyArial FontFamily = "Arial" +) + +// TextAlign enumerates the possible values for the TextAlign type. +type TextAlign = string + +const ( + TextAlignLeft TextAlign = "Left" + TextAlignRight TextAlign = "Right" + TextAlignCenter TextAlign = "Center" +) diff --git a/modelsdk/gen/documenttemplates/refs.go b/modelsdk/gen/documenttemplates/refs.go new file mode 100644 index 00000000..e10bfa88 --- /dev/null +++ b/modelsdk/gen/documenttemplates/refs.go @@ -0,0 +1,31 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package documenttemplates + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("DocumentTemplates$ConditionSettings", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DocumentTemplates$Grid", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DocumentTemplates$DataGrid", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DocumentTemplates$DataView", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DocumentTemplates$DynamicImageViewer", []codec.RefMeta{ + {Prop: "DefaultImage", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DocumentTemplates$StaticImageViewer", []codec.RefMeta{ + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DocumentTemplates$TemplateGrid", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) +} diff --git a/modelsdk/gen/documenttemplates/types.go b/modelsdk/gen/documenttemplates/types.go new file mode 100644 index 00000000..02d3d2f3 --- /dev/null +++ b/modelsdk/gen/documenttemplates/types.go @@ -0,0 +1,3118 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package documenttemplates + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Widget +// ──────────────────────────────────────────────────────── + +type Widget struct { + element.Base + name *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *Widget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Widget) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Widget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// AttributeWidget +// ──────────────────────────────────────────────────────── + +type AttributeWidget struct { + element.Base + name *property.Primitive[string] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *AttributeWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *AttributeWidget) SetName(v string) { + o.name.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *AttributeWidget) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *AttributeWidget) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *AttributeWidget) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *AttributeWidget) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AttributeWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ConditionSettings +// ──────────────────────────────────────────────────────── + +type ConditionSettings struct { + element.Base + conditions *property.PartList[element.Element] + attribute *property.ByNameRef[element.Element] +} + +// ConditionsItems returns the value of the conditions property. +func (o *ConditionSettings) ConditionsItems() []element.Element { + return o.conditions.Items() +} + +// AddConditions appends a child element to the conditions list. +func (o *ConditionSettings) AddConditions(v element.Element) { + o.conditions.Append(v) +} + +// RemoveConditions removes the element at the given index from the conditions list. +func (o *ConditionSettings) RemoveConditions(index int) { + o.conditions.Remove(index) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ConditionSettings) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ConditionSettings) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConditionSettings) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Conditions"); err == nil { + for _, child := range children { + o.conditions.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// EntityWidget +// ──────────────────────────────────────────────────────── + +type EntityWidget struct { + element.Base + name *property.Primitive[string] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *EntityWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *EntityWidget) SetName(v string) { + o.name.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *EntityWidget) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *EntityWidget) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *EntityWidget) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *EntityWidget) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Grid +// ──────────────────────────────────────────────────────── + +type Grid struct { + element.Base + name *property.Primitive[string] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + cellSpacing *property.Primitive[int32] + cellPadding *property.Primitive[int32] + style *property.Part[element.Element] + sortBar *property.Part[element.Element] + microflow *property.ByNameRef[element.Element] +} + +// Name returns the value of the name property. +func (o *Grid) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Grid) SetName(v string) { + o.name.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *Grid) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *Grid) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *Grid) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *Grid) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// CellSpacing returns the value of the cellSpacing property. +func (o *Grid) CellSpacing() int32 { + return o.cellSpacing.Get() +} + +// SetCellSpacing sets the value of the cellSpacing property. +func (o *Grid) SetCellSpacing(v int32) { + o.cellSpacing.Set(v) +} + +// CellPadding returns the value of the cellPadding property. +func (o *Grid) CellPadding() int32 { + return o.cellPadding.Get() +} + +// SetCellPadding sets the value of the cellPadding property. +func (o *Grid) SetCellPadding(v int32) { + o.cellPadding.Set(v) +} + +// Style returns the value of the style property. +func (o *Grid) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Grid) SetStyle(v element.Element) { + o.style.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *Grid) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *Grid) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *Grid) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *Grid) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Grid) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + o.cellSpacing.Init(raw) + o.cellPadding.Init(raw) + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// DataGrid +// ──────────────────────────────────────────────────────── + +type DataGrid struct { + element.Base + name *property.Primitive[string] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + cellSpacing *property.Primitive[int32] + cellPadding *property.Primitive[int32] + style *property.Part[element.Element] + sortBar *property.Part[element.Element] + microflow *property.ByNameRef[element.Element] + columns *property.PartList[element.Element] + weights *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *DataGrid) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataGrid) SetName(v string) { + o.name.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *DataGrid) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *DataGrid) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *DataGrid) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *DataGrid) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// CellSpacing returns the value of the cellSpacing property. +func (o *DataGrid) CellSpacing() int32 { + return o.cellSpacing.Get() +} + +// SetCellSpacing sets the value of the cellSpacing property. +func (o *DataGrid) SetCellSpacing(v int32) { + o.cellSpacing.Set(v) +} + +// CellPadding returns the value of the cellPadding property. +func (o *DataGrid) CellPadding() int32 { + return o.cellPadding.Get() +} + +// SetCellPadding sets the value of the cellPadding property. +func (o *DataGrid) SetCellPadding(v int32) { + o.cellPadding.Set(v) +} + +// Style returns the value of the style property. +func (o *DataGrid) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataGrid) SetStyle(v element.Element) { + o.style.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *DataGrid) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *DataGrid) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *DataGrid) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *DataGrid) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ColumnsItems returns the value of the columns property. +func (o *DataGrid) ColumnsItems() []element.Element { + return o.columns.Items() +} + +// AddColumns appends a child element to the columns list. +func (o *DataGrid) AddColumns(v element.Element) { + o.columns.Append(v) +} + +// RemoveColumns removes the element at the given index from the columns list. +func (o *DataGrid) RemoveColumns(index int) { + o.columns.Remove(index) +} + +// Weights returns the value of the weights property. +func (o *DataGrid) Weights() string { + return o.weights.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataGrid) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + o.cellSpacing.Init(raw) + o.cellPadding.Init(raw) + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Columns"); err == nil { + for _, child := range children { + o.columns.AppendFromDecode(child) + } + } + o.weights.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataGridCell +// ──────────────────────────────────────────────────────── + +type DataGridCell struct { + element.Base + style *property.Part[element.Element] +} + +// Style returns the value of the style property. +func (o *DataGridCell) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataGridCell) SetStyle(v element.Element) { + o.style.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataGridCell) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DataGridColumn +// ──────────────────────────────────────────────────────── + +type DataGridColumn struct { + element.Base + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + caption *property.Part[element.Element] + style *property.Part[element.Element] + oddRowsCell *property.Part[element.Element] + evenRowsCell *property.Part[element.Element] + formattingInfo *property.Part[element.Element] +} + +// AttributePath returns the value of the attributePath property. +func (o *DataGridColumn) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *DataGridColumn) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *DataGridColumn) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *DataGridColumn) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DataGridColumn) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataGridColumn) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Style returns the value of the style property. +func (o *DataGridColumn) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataGridColumn) SetStyle(v element.Element) { + o.style.Set(v) +} + +// OddRowsCell returns the value of the oddRowsCell property. +func (o *DataGridColumn) OddRowsCell() element.Element { + return o.oddRowsCell.Get() +} + +// SetOddRowsCell sets the value of the oddRowsCell property. +func (o *DataGridColumn) SetOddRowsCell(v element.Element) { + o.oddRowsCell.Set(v) +} + +// EvenRowsCell returns the value of the evenRowsCell property. +func (o *DataGridColumn) EvenRowsCell() element.Element { + return o.evenRowsCell.Get() +} + +// SetEvenRowsCell sets the value of the evenRowsCell property. +func (o *DataGridColumn) SetEvenRowsCell(v element.Element) { + o.evenRowsCell.Set(v) +} + +// FormattingInfo returns the value of the formattingInfo property. +func (o *DataGridColumn) FormattingInfo() element.Element { + return o.formattingInfo.Get() +} + +// SetFormattingInfo sets the value of the formattingInfo property. +func (o *DataGridColumn) SetFormattingInfo(v element.Element) { + o.formattingInfo.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataGridColumn) InitFromRaw(raw bson.Raw) { + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OddRowsCell"); err == nil { + o.oddRowsCell.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "EvenRowsCell"); err == nil { + o.evenRowsCell.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "FormattingInfo"); err == nil { + o.formattingInfo.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DataView +// ──────────────────────────────────────────────────────── + +type DataView struct { + element.Base + name *property.Primitive[string] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + contents *property.Part[element.Element] + microflow *property.ByNameRef[element.Element] +} + +// Name returns the value of the name property. +func (o *DataView) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataView) SetName(v string) { + o.name.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *DataView) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *DataView) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *DataView) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *DataView) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// Contents returns the value of the contents property. +func (o *DataView) Contents() element.Element { + return o.contents.Get() +} + +// SetContents sets the value of the contents property. +func (o *DataView) SetContents(v element.Element) { + o.contents.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *DataView) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *DataView) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataView) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Contents"); err == nil { + o.contents.SetFromDecode(child) + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// DropZone +// ──────────────────────────────────────────────────────── + +type DropZone struct { + element.Base + widget *property.Part[element.Element] +} + +// Widget returns the value of the widget property. +func (o *DropZone) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *DropZone) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DropZone) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DataViewContents +// ──────────────────────────────────────────────────────── + +type DataViewContents struct { + element.Base + widget *property.Part[element.Element] +} + +// Widget returns the value of the widget property. +func (o *DataViewContents) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *DataViewContents) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataViewContents) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DocumentTemplate +// ──────────────────────────────────────────────────────── + +type DocumentTemplate struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + toplevels *property.PartList[element.Element] + canvasWidth *property.Primitive[int32] + pageWidth *property.Primitive[string] + pageHeight *property.Primitive[string] + ppi *property.Primitive[int32] + marginLeftInInch *property.Primitive[float64] + marginRightInInch *property.Primitive[float64] + marginTopInInch *property.Primitive[float64] + marginBottomInInch *property.Primitive[float64] + style *property.Part[element.Element] + header *property.Part[element.Element] + footer *property.Part[element.Element] + showHeaderAndFooterOnFirstPage *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *DocumentTemplate) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DocumentTemplate) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *DocumentTemplate) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *DocumentTemplate) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *DocumentTemplate) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *DocumentTemplate) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *DocumentTemplate) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *DocumentTemplate) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ToplevelsItems returns the value of the toplevels property. +func (o *DocumentTemplate) ToplevelsItems() []element.Element { + return o.toplevels.Items() +} + +// AddToplevels appends a child element to the toplevels list. +func (o *DocumentTemplate) AddToplevels(v element.Element) { + o.toplevels.Append(v) +} + +// RemoveToplevels removes the element at the given index from the toplevels list. +func (o *DocumentTemplate) RemoveToplevels(index int) { + o.toplevels.Remove(index) +} + +// CanvasWidth returns the value of the canvasWidth property. +func (o *DocumentTemplate) CanvasWidth() int32 { + return o.canvasWidth.Get() +} + +// SetCanvasWidth sets the value of the canvasWidth property. +func (o *DocumentTemplate) SetCanvasWidth(v int32) { + o.canvasWidth.Set(v) +} + +// PageWidth returns the value of the pageWidth property. +func (o *DocumentTemplate) PageWidth() string { + return o.pageWidth.Get() +} + +// SetPageWidth sets the value of the pageWidth property. +func (o *DocumentTemplate) SetPageWidth(v string) { + o.pageWidth.Set(v) +} + +// PageHeight returns the value of the pageHeight property. +func (o *DocumentTemplate) PageHeight() string { + return o.pageHeight.Get() +} + +// SetPageHeight sets the value of the pageHeight property. +func (o *DocumentTemplate) SetPageHeight(v string) { + o.pageHeight.Set(v) +} + +// Ppi returns the value of the ppi property. +func (o *DocumentTemplate) Ppi() int32 { + return o.ppi.Get() +} + +// SetPpi sets the value of the ppi property. +func (o *DocumentTemplate) SetPpi(v int32) { + o.ppi.Set(v) +} + +// MarginLeftInInch returns the value of the marginLeftInInch property. +func (o *DocumentTemplate) MarginLeftInInch() float64 { + return o.marginLeftInInch.Get() +} + +// SetMarginLeftInInch sets the value of the marginLeftInInch property. +func (o *DocumentTemplate) SetMarginLeftInInch(v float64) { + o.marginLeftInInch.Set(v) +} + +// MarginRightInInch returns the value of the marginRightInInch property. +func (o *DocumentTemplate) MarginRightInInch() float64 { + return o.marginRightInInch.Get() +} + +// SetMarginRightInInch sets the value of the marginRightInInch property. +func (o *DocumentTemplate) SetMarginRightInInch(v float64) { + o.marginRightInInch.Set(v) +} + +// MarginTopInInch returns the value of the marginTopInInch property. +func (o *DocumentTemplate) MarginTopInInch() float64 { + return o.marginTopInInch.Get() +} + +// SetMarginTopInInch sets the value of the marginTopInInch property. +func (o *DocumentTemplate) SetMarginTopInInch(v float64) { + o.marginTopInInch.Set(v) +} + +// MarginBottomInInch returns the value of the marginBottomInInch property. +func (o *DocumentTemplate) MarginBottomInInch() float64 { + return o.marginBottomInInch.Get() +} + +// SetMarginBottomInInch sets the value of the marginBottomInInch property. +func (o *DocumentTemplate) SetMarginBottomInInch(v float64) { + o.marginBottomInInch.Set(v) +} + +// Style returns the value of the style property. +func (o *DocumentTemplate) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DocumentTemplate) SetStyle(v element.Element) { + o.style.Set(v) +} + +// Header returns the value of the header property. +func (o *DocumentTemplate) Header() element.Element { + return o.header.Get() +} + +// SetHeader sets the value of the header property. +func (o *DocumentTemplate) SetHeader(v element.Element) { + o.header.Set(v) +} + +// Footer returns the value of the footer property. +func (o *DocumentTemplate) Footer() element.Element { + return o.footer.Get() +} + +// SetFooter sets the value of the footer property. +func (o *DocumentTemplate) SetFooter(v element.Element) { + o.footer.Set(v) +} + +// ShowHeaderAndFooterOnFirstPage returns the value of the showHeaderAndFooterOnFirstPage property. +func (o *DocumentTemplate) ShowHeaderAndFooterOnFirstPage() bool { + return o.showHeaderAndFooterOnFirstPage.Get() +} + +// SetShowHeaderAndFooterOnFirstPage sets the value of the showHeaderAndFooterOnFirstPage property. +func (o *DocumentTemplate) SetShowHeaderAndFooterOnFirstPage(v bool) { + o.showHeaderAndFooterOnFirstPage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DocumentTemplate) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Toplevels"); err == nil { + for _, child := range children { + o.toplevels.AppendFromDecode(child) + } + } + o.canvasWidth.Init(raw) + o.pageWidth.Init(raw) + o.pageHeight.Init(raw) + o.ppi.Init(raw) + o.marginLeftInInch.Init(raw) + o.marginRightInInch.Init(raw) + o.marginTopInInch.Init(raw) + o.marginBottomInInch.Init(raw) + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Header"); err == nil { + o.header.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Footer"); err == nil { + o.footer.SetFromDecode(child) + } + o.showHeaderAndFooterOnFirstPage.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DocumentTemplateParameter +// ──────────────────────────────────────────────────────── + +type DocumentTemplateParameter struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + parameterType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DocumentTemplateParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DocumentTemplateParameter) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *DocumentTemplateParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *DocumentTemplateParameter) SetType(v string) { + o.propType.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *DocumentTemplateParameter) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *DocumentTemplateParameter) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DocumentTemplateParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DynamicImageViewer +// ──────────────────────────────────────────────────────── + +type DynamicImageViewer struct { + element.Base + name *property.Primitive[string] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + defaultImage *property.ByNameRef[element.Element] + useThumbnail *property.Primitive[bool] + width *property.Primitive[int32] + height *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *DynamicImageViewer) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DynamicImageViewer) SetName(v string) { + o.name.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *DynamicImageViewer) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *DynamicImageViewer) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *DynamicImageViewer) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *DynamicImageViewer) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// DefaultImageQualifiedName returns the value of the defaultImage property. +func (o *DynamicImageViewer) DefaultImageQualifiedName() string { + return o.defaultImage.QualifiedName() +} + +// SetDefaultImageQualifiedName sets the value of the defaultImage property. +func (o *DynamicImageViewer) SetDefaultImageQualifiedName(v string) { + o.defaultImage.SetQualifiedName(v) +} + +// UseThumbnail returns the value of the useThumbnail property. +func (o *DynamicImageViewer) UseThumbnail() bool { + return o.useThumbnail.Get() +} + +// SetUseThumbnail sets the value of the useThumbnail property. +func (o *DynamicImageViewer) SetUseThumbnail(v bool) { + o.useThumbnail.Set(v) +} + +// Width returns the value of the width property. +func (o *DynamicImageViewer) Width() int32 { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *DynamicImageViewer) SetWidth(v int32) { + o.width.Set(v) +} + +// Height returns the value of the height property. +func (o *DynamicImageViewer) Height() int32 { + return o.height.Get() +} + +// SetHeight sets the value of the height property. +func (o *DynamicImageViewer) SetHeight(v int32) { + o.height.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DynamicImageViewer) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("DefaultImage"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.defaultImage.SetFromDecode(s) + } + } + o.useThumbnail.Init(raw) + o.width.Init(raw) + o.height.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DynamicLabel +// ──────────────────────────────────────────────────────── + +type DynamicLabel struct { + element.Base + name *property.Primitive[string] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + style *property.Part[element.Element] + renderXHTML *property.Primitive[bool] + formattingInfo *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DynamicLabel) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DynamicLabel) SetName(v string) { + o.name.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *DynamicLabel) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *DynamicLabel) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *DynamicLabel) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *DynamicLabel) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// Style returns the value of the style property. +func (o *DynamicLabel) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DynamicLabel) SetStyle(v element.Element) { + o.style.Set(v) +} + +// RenderXHTML returns the value of the renderXHTML property. +func (o *DynamicLabel) RenderXHTML() bool { + return o.renderXHTML.Get() +} + +// SetRenderXHTML sets the value of the renderXHTML property. +func (o *DynamicLabel) SetRenderXHTML(v bool) { + o.renderXHTML.Set(v) +} + +// FormattingInfo returns the value of the formattingInfo property. +func (o *DynamicLabel) FormattingInfo() element.Element { + return o.formattingInfo.Get() +} + +// SetFormattingInfo sets the value of the formattingInfo property. +func (o *DynamicLabel) SetFormattingInfo(v element.Element) { + o.formattingInfo.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DynamicLabel) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } + o.renderXHTML.Init(raw) + if child, err := codec.DecodeChild(raw, "FormattingInfo"); err == nil { + o.formattingInfo.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Footer +// ──────────────────────────────────────────────────────── + +type Footer struct { + element.Base + widget *property.Part[element.Element] + bottomMargin *property.Primitive[float64] +} + +// Widget returns the value of the widget property. +func (o *Footer) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *Footer) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// BottomMargin returns the value of the bottomMargin property. +func (o *Footer) BottomMargin() float64 { + return o.bottomMargin.Get() +} + +// SetBottomMargin sets the value of the bottomMargin property. +func (o *Footer) SetBottomMargin(v float64) { + o.bottomMargin.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Footer) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + o.bottomMargin.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// GridSortBar +// ──────────────────────────────────────────────────────── + +type GridSortBar struct { + element.Base + sortItems *property.PartList[element.Element] +} + +// SortItemsItems returns the value of the sortItems property. +func (o *GridSortBar) SortItemsItems() []element.Element { + return o.sortItems.Items() +} + +// AddSortItems appends a child element to the sortItems list. +func (o *GridSortBar) AddSortItems(v element.Element) { + o.sortItems.Append(v) +} + +// RemoveSortItems removes the element at the given index from the sortItems list. +func (o *GridSortBar) RemoveSortItems(index int) { + o.sortItems.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridSortBar) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "SortItems"); err == nil { + for _, child := range children { + o.sortItems.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// GridSortItem +// ──────────────────────────────────────────────────────── + +type GridSortItem struct { + element.Base + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + sortOrder *property.Enum[string] +} + +// AttributePath returns the value of the attributePath property. +func (o *GridSortItem) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *GridSortItem) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *GridSortItem) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *GridSortItem) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// SortOrder returns the value of the sortOrder property. +func (o *GridSortItem) SortOrder() string { + return o.sortOrder.Get() +} + +// SetSortOrder sets the value of the sortOrder property. +func (o *GridSortItem) SetSortOrder(v string) { + o.sortOrder.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridSortItem) InitFromRaw(raw bson.Raw) { + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("SortOrder"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.sortOrder.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// Header +// ──────────────────────────────────────────────────────── + +type Header struct { + element.Base + widget *property.Part[element.Element] + topMargin *property.Primitive[float64] +} + +// Widget returns the value of the widget property. +func (o *Header) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *Header) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// TopMargin returns the value of the topMargin property. +func (o *Header) TopMargin() float64 { + return o.topMargin.Get() +} + +// SetTopMargin sets the value of the topMargin property. +func (o *Header) SetTopMargin(v float64) { + o.topMargin.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Header) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + o.topMargin.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LineBreak +// ──────────────────────────────────────────────────────── + +type LineBreak struct { + element.Base + name *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *LineBreak) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *LineBreak) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LineBreak) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PageBreak +// ──────────────────────────────────────────────────────── + +type PageBreak struct { + element.Base + name *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *PageBreak) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PageBreak) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PageBreak) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// StaticImageViewer +// ──────────────────────────────────────────────────────── + +type StaticImageViewer struct { + element.Base + name *property.Primitive[string] + image *property.ByNameRef[element.Element] + width *property.Primitive[int32] + height *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *StaticImageViewer) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *StaticImageViewer) SetName(v string) { + o.name.Set(v) +} + +// ImageQualifiedName returns the value of the image property. +func (o *StaticImageViewer) ImageQualifiedName() string { + return o.image.QualifiedName() +} + +// SetImageQualifiedName sets the value of the image property. +func (o *StaticImageViewer) SetImageQualifiedName(v string) { + o.image.SetQualifiedName(v) +} + +// Width returns the value of the width property. +func (o *StaticImageViewer) Width() int32 { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *StaticImageViewer) SetWidth(v int32) { + o.width.Set(v) +} + +// Height returns the value of the height property. +func (o *StaticImageViewer) Height() int32 { + return o.height.Get() +} + +// SetHeight sets the value of the height property. +func (o *StaticImageViewer) SetHeight(v int32) { + o.height.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StaticImageViewer) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if val, err := raw.LookupErr("Image"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.image.SetFromDecode(s) + } + } + o.width.Init(raw) + o.height.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// StaticLabel +// ──────────────────────────────────────────────────────── + +type StaticLabel struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + style *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *StaticLabel) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *StaticLabel) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *StaticLabel) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *StaticLabel) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Style returns the value of the style property. +func (o *StaticLabel) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *StaticLabel) SetStyle(v element.Element) { + o.style.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StaticLabel) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Style +// ──────────────────────────────────────────────────────── + +type Style struct { + element.Base + fontFamily *property.Enum[string] + fontSize *property.Primitive[int32] + bold *property.Primitive[bool] + italic *property.Primitive[bool] + fontColor *property.Primitive[string] + backgroundColor *property.Primitive[string] + overrideFontFamily *property.Primitive[bool] + overrideFontSize *property.Primitive[bool] + overrideBold *property.Primitive[bool] + overrideItalic *property.Primitive[bool] + overrideFontColor *property.Primitive[bool] + overrideBackgroundColor *property.Primitive[bool] + borderStyleTop *property.Enum[string] + borderStyleBottom *property.Enum[string] + borderStyleLeft *property.Enum[string] + borderStyleRight *property.Enum[string] + borderWidthTop *property.Primitive[int32] + borderWidthBottom *property.Primitive[int32] + borderWidthLeft *property.Primitive[int32] + borderWidthRight *property.Primitive[int32] + borderColorTop *property.Primitive[string] + borderColorBottom *property.Primitive[string] + borderColorLeft *property.Primitive[string] + borderColorRight *property.Primitive[string] + textAlign *property.Enum[string] + customStyles *property.Primitive[string] +} + +// FontFamily returns the value of the fontFamily property. +func (o *Style) FontFamily() string { + return o.fontFamily.Get() +} + +// SetFontFamily sets the value of the fontFamily property. +func (o *Style) SetFontFamily(v string) { + o.fontFamily.Set(v) +} + +// FontSize returns the value of the fontSize property. +func (o *Style) FontSize() int32 { + return o.fontSize.Get() +} + +// SetFontSize sets the value of the fontSize property. +func (o *Style) SetFontSize(v int32) { + o.fontSize.Set(v) +} + +// Bold returns the value of the bold property. +func (o *Style) Bold() bool { + return o.bold.Get() +} + +// SetBold sets the value of the bold property. +func (o *Style) SetBold(v bool) { + o.bold.Set(v) +} + +// Italic returns the value of the italic property. +func (o *Style) Italic() bool { + return o.italic.Get() +} + +// SetItalic sets the value of the italic property. +func (o *Style) SetItalic(v bool) { + o.italic.Set(v) +} + +// FontColor returns the value of the fontColor property. +func (o *Style) FontColor() string { + return o.fontColor.Get() +} + +// SetFontColor sets the value of the fontColor property. +func (o *Style) SetFontColor(v string) { + o.fontColor.Set(v) +} + +// BackgroundColor returns the value of the backgroundColor property. +func (o *Style) BackgroundColor() string { + return o.backgroundColor.Get() +} + +// SetBackgroundColor sets the value of the backgroundColor property. +func (o *Style) SetBackgroundColor(v string) { + o.backgroundColor.Set(v) +} + +// OverrideFontFamily returns the value of the overrideFontFamily property. +func (o *Style) OverrideFontFamily() bool { + return o.overrideFontFamily.Get() +} + +// SetOverrideFontFamily sets the value of the overrideFontFamily property. +func (o *Style) SetOverrideFontFamily(v bool) { + o.overrideFontFamily.Set(v) +} + +// OverrideFontSize returns the value of the overrideFontSize property. +func (o *Style) OverrideFontSize() bool { + return o.overrideFontSize.Get() +} + +// SetOverrideFontSize sets the value of the overrideFontSize property. +func (o *Style) SetOverrideFontSize(v bool) { + o.overrideFontSize.Set(v) +} + +// OverrideBold returns the value of the overrideBold property. +func (o *Style) OverrideBold() bool { + return o.overrideBold.Get() +} + +// SetOverrideBold sets the value of the overrideBold property. +func (o *Style) SetOverrideBold(v bool) { + o.overrideBold.Set(v) +} + +// OverrideItalic returns the value of the overrideItalic property. +func (o *Style) OverrideItalic() bool { + return o.overrideItalic.Get() +} + +// SetOverrideItalic sets the value of the overrideItalic property. +func (o *Style) SetOverrideItalic(v bool) { + o.overrideItalic.Set(v) +} + +// OverrideFontColor returns the value of the overrideFontColor property. +func (o *Style) OverrideFontColor() bool { + return o.overrideFontColor.Get() +} + +// SetOverrideFontColor sets the value of the overrideFontColor property. +func (o *Style) SetOverrideFontColor(v bool) { + o.overrideFontColor.Set(v) +} + +// OverrideBackgroundColor returns the value of the overrideBackgroundColor property. +func (o *Style) OverrideBackgroundColor() bool { + return o.overrideBackgroundColor.Get() +} + +// SetOverrideBackgroundColor sets the value of the overrideBackgroundColor property. +func (o *Style) SetOverrideBackgroundColor(v bool) { + o.overrideBackgroundColor.Set(v) +} + +// BorderStyleTop returns the value of the borderStyleTop property. +func (o *Style) BorderStyleTop() string { + return o.borderStyleTop.Get() +} + +// SetBorderStyleTop sets the value of the borderStyleTop property. +func (o *Style) SetBorderStyleTop(v string) { + o.borderStyleTop.Set(v) +} + +// BorderStyleBottom returns the value of the borderStyleBottom property. +func (o *Style) BorderStyleBottom() string { + return o.borderStyleBottom.Get() +} + +// SetBorderStyleBottom sets the value of the borderStyleBottom property. +func (o *Style) SetBorderStyleBottom(v string) { + o.borderStyleBottom.Set(v) +} + +// BorderStyleLeft returns the value of the borderStyleLeft property. +func (o *Style) BorderStyleLeft() string { + return o.borderStyleLeft.Get() +} + +// SetBorderStyleLeft sets the value of the borderStyleLeft property. +func (o *Style) SetBorderStyleLeft(v string) { + o.borderStyleLeft.Set(v) +} + +// BorderStyleRight returns the value of the borderStyleRight property. +func (o *Style) BorderStyleRight() string { + return o.borderStyleRight.Get() +} + +// SetBorderStyleRight sets the value of the borderStyleRight property. +func (o *Style) SetBorderStyleRight(v string) { + o.borderStyleRight.Set(v) +} + +// BorderWidthTop returns the value of the borderWidthTop property. +func (o *Style) BorderWidthTop() int32 { + return o.borderWidthTop.Get() +} + +// SetBorderWidthTop sets the value of the borderWidthTop property. +func (o *Style) SetBorderWidthTop(v int32) { + o.borderWidthTop.Set(v) +} + +// BorderWidthBottom returns the value of the borderWidthBottom property. +func (o *Style) BorderWidthBottom() int32 { + return o.borderWidthBottom.Get() +} + +// SetBorderWidthBottom sets the value of the borderWidthBottom property. +func (o *Style) SetBorderWidthBottom(v int32) { + o.borderWidthBottom.Set(v) +} + +// BorderWidthLeft returns the value of the borderWidthLeft property. +func (o *Style) BorderWidthLeft() int32 { + return o.borderWidthLeft.Get() +} + +// SetBorderWidthLeft sets the value of the borderWidthLeft property. +func (o *Style) SetBorderWidthLeft(v int32) { + o.borderWidthLeft.Set(v) +} + +// BorderWidthRight returns the value of the borderWidthRight property. +func (o *Style) BorderWidthRight() int32 { + return o.borderWidthRight.Get() +} + +// SetBorderWidthRight sets the value of the borderWidthRight property. +func (o *Style) SetBorderWidthRight(v int32) { + o.borderWidthRight.Set(v) +} + +// BorderColorTop returns the value of the borderColorTop property. +func (o *Style) BorderColorTop() string { + return o.borderColorTop.Get() +} + +// SetBorderColorTop sets the value of the borderColorTop property. +func (o *Style) SetBorderColorTop(v string) { + o.borderColorTop.Set(v) +} + +// BorderColorBottom returns the value of the borderColorBottom property. +func (o *Style) BorderColorBottom() string { + return o.borderColorBottom.Get() +} + +// SetBorderColorBottom sets the value of the borderColorBottom property. +func (o *Style) SetBorderColorBottom(v string) { + o.borderColorBottom.Set(v) +} + +// BorderColorLeft returns the value of the borderColorLeft property. +func (o *Style) BorderColorLeft() string { + return o.borderColorLeft.Get() +} + +// SetBorderColorLeft sets the value of the borderColorLeft property. +func (o *Style) SetBorderColorLeft(v string) { + o.borderColorLeft.Set(v) +} + +// BorderColorRight returns the value of the borderColorRight property. +func (o *Style) BorderColorRight() string { + return o.borderColorRight.Get() +} + +// SetBorderColorRight sets the value of the borderColorRight property. +func (o *Style) SetBorderColorRight(v string) { + o.borderColorRight.Set(v) +} + +// TextAlign returns the value of the textAlign property. +func (o *Style) TextAlign() string { + return o.textAlign.Get() +} + +// SetTextAlign sets the value of the textAlign property. +func (o *Style) SetTextAlign(v string) { + o.textAlign.Set(v) +} + +// CustomStyles returns the value of the customStyles property. +func (o *Style) CustomStyles() string { + return o.customStyles.Get() +} + +// SetCustomStyles sets the value of the customStyles property. +func (o *Style) SetCustomStyles(v string) { + o.customStyles.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Style) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("FontFamily"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.fontFamily.SetFromDecode(s) + } + } + o.fontSize.Init(raw) + o.bold.Init(raw) + o.italic.Init(raw) + o.fontColor.Init(raw) + o.backgroundColor.Init(raw) + o.overrideFontFamily.Init(raw) + o.overrideFontSize.Init(raw) + o.overrideBold.Init(raw) + o.overrideItalic.Init(raw) + o.overrideFontColor.Init(raw) + o.overrideBackgroundColor.Init(raw) + if val, err := raw.LookupErr("BorderStyleTop"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.borderStyleTop.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("BorderStyleBottom"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.borderStyleBottom.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("BorderStyleLeft"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.borderStyleLeft.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("BorderStyleRight"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.borderStyleRight.SetFromDecode(s) + } + } + o.borderWidthTop.Init(raw) + o.borderWidthBottom.Init(raw) + o.borderWidthLeft.Init(raw) + o.borderWidthRight.Init(raw) + o.borderColorTop.Init(raw) + o.borderColorBottom.Init(raw) + o.borderColorLeft.Init(raw) + o.borderColorRight.Init(raw) + if val, err := raw.LookupErr("TextAlign"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.textAlign.SetFromDecode(s) + } + } + o.customStyles.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Table +// ──────────────────────────────────────────────────────── + +type Table struct { + element.Base + name *property.Primitive[string] + rows *property.PartList[element.Element] + columnWeights *property.Primitive[string] + cellSpacing *property.Primitive[int32] + cellPadding *property.Primitive[int32] + style *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *Table) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Table) SetName(v string) { + o.name.Set(v) +} + +// RowsItems returns the value of the rows property. +func (o *Table) RowsItems() []element.Element { + return o.rows.Items() +} + +// AddRows appends a child element to the rows list. +func (o *Table) AddRows(v element.Element) { + o.rows.Append(v) +} + +// RemoveRows removes the element at the given index from the rows list. +func (o *Table) RemoveRows(index int) { + o.rows.Remove(index) +} + +// ColumnWeights returns the value of the columnWeights property. +func (o *Table) ColumnWeights() string { + return o.columnWeights.Get() +} + +// CellSpacing returns the value of the cellSpacing property. +func (o *Table) CellSpacing() int32 { + return o.cellSpacing.Get() +} + +// SetCellSpacing sets the value of the cellSpacing property. +func (o *Table) SetCellSpacing(v int32) { + o.cellSpacing.Set(v) +} + +// CellPadding returns the value of the cellPadding property. +func (o *Table) CellPadding() int32 { + return o.cellPadding.Get() +} + +// SetCellPadding sets the value of the cellPadding property. +func (o *Table) SetCellPadding(v int32) { + o.cellPadding.Set(v) +} + +// Style returns the value of the style property. +func (o *Table) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Table) SetStyle(v element.Element) { + o.style.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Table) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if children, err := codec.DecodeChildren(raw, "Rows"); err == nil { + for _, child := range children { + o.rows.AppendFromDecode(child) + } + } + o.columnWeights.Init(raw) + o.cellSpacing.Init(raw) + o.cellPadding.Init(raw) + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TableCell +// ──────────────────────────────────────────────────────── + +type TableCell struct { + element.Base + widget *property.Part[element.Element] + colSpan *property.Primitive[int32] + rowSpan *property.Primitive[int32] + isPartOfSpan *property.Primitive[bool] + style *property.Part[element.Element] +} + +// Widget returns the value of the widget property. +func (o *TableCell) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *TableCell) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// ColSpan returns the value of the colSpan property. +func (o *TableCell) ColSpan() int32 { + return o.colSpan.Get() +} + +// SetColSpan sets the value of the colSpan property. +func (o *TableCell) SetColSpan(v int32) { + o.colSpan.Set(v) +} + +// RowSpan returns the value of the rowSpan property. +func (o *TableCell) RowSpan() int32 { + return o.rowSpan.Get() +} + +// SetRowSpan sets the value of the rowSpan property. +func (o *TableCell) SetRowSpan(v int32) { + o.rowSpan.Set(v) +} + +// IsPartOfSpan returns the value of the isPartOfSpan property. +func (o *TableCell) IsPartOfSpan() bool { + return o.isPartOfSpan.Get() +} + +// SetIsPartOfSpan sets the value of the isPartOfSpan property. +func (o *TableCell) SetIsPartOfSpan(v bool) { + o.isPartOfSpan.Set(v) +} + +// Style returns the value of the style property. +func (o *TableCell) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *TableCell) SetStyle(v element.Element) { + o.style.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TableCell) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + o.colSpan.Init(raw) + o.rowSpan.Init(raw) + o.isPartOfSpan.Init(raw) + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TableRow +// ──────────────────────────────────────────────────────── + +type TableRow struct { + element.Base + cells *property.PartList[element.Element] + conditionSettings *property.Part[element.Element] +} + +// CellsItems returns the value of the cells property. +func (o *TableRow) CellsItems() []element.Element { + return o.cells.Items() +} + +// AddCells appends a child element to the cells list. +func (o *TableRow) AddCells(v element.Element) { + o.cells.Append(v) +} + +// RemoveCells removes the element at the given index from the cells list. +func (o *TableRow) RemoveCells(index int) { + o.cells.Remove(index) +} + +// ConditionSettings returns the value of the conditionSettings property. +func (o *TableRow) ConditionSettings() element.Element { + return o.conditionSettings.Get() +} + +// SetConditionSettings sets the value of the conditionSettings property. +func (o *TableRow) SetConditionSettings(v element.Element) { + o.conditionSettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TableRow) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Cells"); err == nil { + for _, child := range children { + o.cells.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ConditionSettings"); err == nil { + o.conditionSettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TemplateGrid +// ──────────────────────────────────────────────────────── + +type TemplateGrid struct { + element.Base + name *property.Primitive[string] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + cellSpacing *property.Primitive[int32] + cellPadding *property.Primitive[int32] + style *property.Part[element.Element] + sortBar *property.Part[element.Element] + microflow *property.ByNameRef[element.Element] + numberOfColumns *property.Primitive[int32] + oddRowsContents *property.Part[element.Element] + evenRowsContents *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *TemplateGrid) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TemplateGrid) SetName(v string) { + o.name.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *TemplateGrid) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *TemplateGrid) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *TemplateGrid) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *TemplateGrid) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// CellSpacing returns the value of the cellSpacing property. +func (o *TemplateGrid) CellSpacing() int32 { + return o.cellSpacing.Get() +} + +// SetCellSpacing sets the value of the cellSpacing property. +func (o *TemplateGrid) SetCellSpacing(v int32) { + o.cellSpacing.Set(v) +} + +// CellPadding returns the value of the cellPadding property. +func (o *TemplateGrid) CellPadding() int32 { + return o.cellPadding.Get() +} + +// SetCellPadding sets the value of the cellPadding property. +func (o *TemplateGrid) SetCellPadding(v int32) { + o.cellPadding.Set(v) +} + +// Style returns the value of the style property. +func (o *TemplateGrid) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *TemplateGrid) SetStyle(v element.Element) { + o.style.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *TemplateGrid) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *TemplateGrid) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *TemplateGrid) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *TemplateGrid) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// NumberOfColumns returns the value of the numberOfColumns property. +func (o *TemplateGrid) NumberOfColumns() int32 { + return o.numberOfColumns.Get() +} + +// SetNumberOfColumns sets the value of the numberOfColumns property. +func (o *TemplateGrid) SetNumberOfColumns(v int32) { + o.numberOfColumns.Set(v) +} + +// OddRowsContents returns the value of the oddRowsContents property. +func (o *TemplateGrid) OddRowsContents() element.Element { + return o.oddRowsContents.Get() +} + +// SetOddRowsContents sets the value of the oddRowsContents property. +func (o *TemplateGrid) SetOddRowsContents(v element.Element) { + o.oddRowsContents.Set(v) +} + +// EvenRowsContents returns the value of the evenRowsContents property. +func (o *TemplateGrid) EvenRowsContents() element.Element { + return o.evenRowsContents.Get() +} + +// SetEvenRowsContents sets the value of the evenRowsContents property. +func (o *TemplateGrid) SetEvenRowsContents(v element.Element) { + o.evenRowsContents.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TemplateGrid) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + o.cellSpacing.Init(raw) + o.cellPadding.Init(raw) + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + o.numberOfColumns.Init(raw) + if child, err := codec.DecodeChild(raw, "OddRowsContents"); err == nil { + o.oddRowsContents.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "EvenRowsContents"); err == nil { + o.evenRowsContents.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TemplateGridContents +// ──────────────────────────────────────────────────────── + +type TemplateGridContents struct { + element.Base + widget *property.Part[element.Element] +} + +// Widget returns the value of the widget property. +func (o *TemplateGridContents) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *TemplateGridContents) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TemplateGridContents) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Title +// ──────────────────────────────────────────────────────── + +type Title struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + style *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *Title) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Title) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *Title) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *Title) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Style returns the value of the style property. +func (o *Title) Style() element.Element { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Title) SetStyle(v element.Element) { + o.style.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Title) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Style"); err == nil { + o.style.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initConditionSettings creates a ConditionSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConditionSettings() *ConditionSettings { + o := &ConditionSettings{} + o.SetTypeName("DocumentTemplates$ConditionSettings") + o.conditions = property.NewPartList[element.Element]("Conditions") + o.conditions.Bind(&o.Base, 0) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.conditions, o.attribute}) + return o +} + +// NewConditionSettings creates a new ConditionSettings for user code. Marked dirty (bit 63 = new element). +func NewConditionSettings() *ConditionSettings { + o := initConditionSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataGrid creates a DataGrid with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataGrid() *DataGrid { + o := &DataGrid{} + o.SetTypeName("DocumentTemplates$DataGrid") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.cellSpacing = property.NewPrimitive[int32]("CellSpacing", property.DecodeInt32) + o.cellSpacing.Bind(&o.Base, 3) + o.cellPadding = property.NewPrimitive[int32]("CellPadding", property.DecodeInt32) + o.cellPadding.Bind(&o.Base, 4) + o.style = property.NewPart[element.Element]("Style") + o.style.Bind(&o.Base, 5) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 6) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 7) + o.columns = property.NewPartList[element.Element]("Columns") + o.columns.Bind(&o.Base, 8) + o.weights = property.NewPrimitive[string]("Weights", property.DecodeString) + o.weights.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.name, o.entityPath, o.entityRef, o.cellSpacing, o.cellPadding, o.style, o.sortBar, o.microflow, o.columns, o.weights}) + return o +} + +// NewDataGrid creates a new DataGrid for user code. Marked dirty (bit 63 = new element). +func NewDataGrid() *DataGrid { + o := initDataGrid() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataGridCell creates a DataGridCell with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataGridCell() *DataGridCell { + o := &DataGridCell{} + o.SetTypeName("DocumentTemplates$DataGridCell") + o.style = property.NewPart[element.Element]("Style") + o.style.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.style}) + return o +} + +// NewDataGridCell creates a new DataGridCell for user code. Marked dirty (bit 63 = new element). +func NewDataGridCell() *DataGridCell { + o := initDataGridCell() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataGridColumn creates a DataGridColumn with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataGridColumn() *DataGridColumn { + o := &DataGridColumn{} + o.SetTypeName("Forms$DataGridColumn") + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 0) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 1) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 2) + o.style = property.NewPart[element.Element]("Style") + o.style.Bind(&o.Base, 3) + o.oddRowsCell = property.NewPart[element.Element]("OddRowsCell") + o.oddRowsCell.Bind(&o.Base, 4) + o.evenRowsCell = property.NewPart[element.Element]("EvenRowsCell") + o.evenRowsCell.Bind(&o.Base, 5) + o.formattingInfo = property.NewPart[element.Element]("FormattingInfo") + o.formattingInfo.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.attributePath, o.attributeRef, o.caption, o.style, o.oddRowsCell, o.evenRowsCell, o.formattingInfo}) + return o +} + +// NewDataGridColumn creates a new DataGridColumn for user code. Marked dirty (bit 63 = new element). +func NewDataGridColumn() *DataGridColumn { + o := initDataGridColumn() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataView creates a DataView with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataView() *DataView { + o := &DataView{} + o.SetTypeName("DocumentTemplates$DataView") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.contents = property.NewPart[element.Element]("Contents") + o.contents.Bind(&o.Base, 3) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.entityPath, o.entityRef, o.contents, o.microflow}) + return o +} + +// NewDataView creates a new DataView for user code. Marked dirty (bit 63 = new element). +func NewDataView() *DataView { + o := initDataView() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataViewContents creates a DataViewContents with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataViewContents() *DataViewContents { + o := &DataViewContents{} + o.SetTypeName("DocumentTemplates$DataViewContents") + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.widget}) + return o +} + +// NewDataViewContents creates a new DataViewContents for user code. Marked dirty (bit 63 = new element). +func NewDataViewContents() *DataViewContents { + o := initDataViewContents() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDocumentTemplate creates a DocumentTemplate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDocumentTemplate() *DocumentTemplate { + o := &DocumentTemplate{} + o.SetTypeName("DocumentTemplates$DocumentTemplate") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.toplevels = property.NewPartList[element.Element]("Toplevels") + o.toplevels.Bind(&o.Base, 4) + o.canvasWidth = property.NewPrimitive[int32]("CanvasWidth", property.DecodeInt32) + o.canvasWidth.Bind(&o.Base, 5) + o.pageWidth = property.NewPrimitive[string]("PageWidth", property.DecodeString) + o.pageWidth.Bind(&o.Base, 6) + o.pageHeight = property.NewPrimitive[string]("PageHeight", property.DecodeString) + o.pageHeight.Bind(&o.Base, 7) + o.ppi = property.NewPrimitive[int32]("Ppi", property.DecodeInt32) + o.ppi.Bind(&o.Base, 8) + o.marginLeftInInch = property.NewPrimitive[float64]("MarginLeftInInch", property.DecodeFloat64) + o.marginLeftInInch.Bind(&o.Base, 9) + o.marginRightInInch = property.NewPrimitive[float64]("MarginRightInInch", property.DecodeFloat64) + o.marginRightInInch.Bind(&o.Base, 10) + o.marginTopInInch = property.NewPrimitive[float64]("MarginTopInInch", property.DecodeFloat64) + o.marginTopInInch.Bind(&o.Base, 11) + o.marginBottomInInch = property.NewPrimitive[float64]("MarginBottomInInch", property.DecodeFloat64) + o.marginBottomInInch.Bind(&o.Base, 12) + o.style = property.NewPart[element.Element]("Style") + o.style.Bind(&o.Base, 13) + o.header = property.NewPart[element.Element]("Header") + o.header.Bind(&o.Base, 14) + o.footer = property.NewPart[element.Element]("Footer") + o.footer.Bind(&o.Base, 15) + o.showHeaderAndFooterOnFirstPage = property.NewPrimitive[bool]("ShowHeaderAndFooterOnFirstPage", property.DecodeBool) + o.showHeaderAndFooterOnFirstPage.Bind(&o.Base, 16) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.toplevels, o.canvasWidth, o.pageWidth, o.pageHeight, o.ppi, o.marginLeftInInch, o.marginRightInInch, o.marginTopInInch, o.marginBottomInInch, o.style, o.header, o.footer, o.showHeaderAndFooterOnFirstPage}) + return o +} + +// NewDocumentTemplate creates a new DocumentTemplate for user code. Marked dirty (bit 63 = new element). +func NewDocumentTemplate() *DocumentTemplate { + o := initDocumentTemplate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDynamicImageViewer creates a DynamicImageViewer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDynamicImageViewer() *DynamicImageViewer { + o := &DynamicImageViewer{} + o.SetTypeName("DocumentTemplates$DynamicImageViewer") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.defaultImage = property.NewByNameRef[element.Element]("DefaultImage", "Images$Image") + o.defaultImage.Bind(&o.Base, 3) + o.useThumbnail = property.NewPrimitive[bool]("UseThumbnail", property.DecodeBool) + o.useThumbnail.Bind(&o.Base, 4) + o.width = property.NewPrimitive[int32]("Width", property.DecodeInt32) + o.width.Bind(&o.Base, 5) + o.height = property.NewPrimitive[int32]("Height", property.DecodeInt32) + o.height.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.entityPath, o.entityRef, o.defaultImage, o.useThumbnail, o.width, o.height}) + return o +} + +// NewDynamicImageViewer creates a new DynamicImageViewer for user code. Marked dirty (bit 63 = new element). +func NewDynamicImageViewer() *DynamicImageViewer { + o := initDynamicImageViewer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDynamicLabel creates a DynamicLabel with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDynamicLabel() *DynamicLabel { + o := &DynamicLabel{} + o.SetTypeName("DocumentTemplates$DynamicLabel") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 1) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 2) + o.style = property.NewPart[element.Element]("Style") + o.style.Bind(&o.Base, 3) + o.renderXHTML = property.NewPrimitive[bool]("RenderXHTML", property.DecodeBool) + o.renderXHTML.Bind(&o.Base, 4) + o.formattingInfo = property.NewPart[element.Element]("FormattingInfo") + o.formattingInfo.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.attributePath, o.attributeRef, o.style, o.renderXHTML, o.formattingInfo}) + return o +} + +// NewDynamicLabel creates a new DynamicLabel for user code. Marked dirty (bit 63 = new element). +func NewDynamicLabel() *DynamicLabel { + o := initDynamicLabel() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFooter creates a Footer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFooter() *Footer { + o := &Footer{} + o.SetTypeName("DocumentTemplates$Footer") + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 0) + o.bottomMargin = property.NewPrimitive[float64]("BottomMargin", property.DecodeFloat64) + o.bottomMargin.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.widget, o.bottomMargin}) + return o +} + +// NewFooter creates a new Footer for user code. Marked dirty (bit 63 = new element). +func NewFooter() *Footer { + o := initFooter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridSortBar creates a GridSortBar with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridSortBar() *GridSortBar { + o := &GridSortBar{} + o.SetTypeName("DocumentTemplates$GridSortBar") + o.sortItems = property.NewPartList[element.Element]("SortItems") + o.sortItems.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.sortItems}) + return o +} + +// NewGridSortBar creates a new GridSortBar for user code. Marked dirty (bit 63 = new element). +func NewGridSortBar() *GridSortBar { + o := initGridSortBar() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridSortItem creates a GridSortItem with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridSortItem() *GridSortItem { + o := &GridSortItem{} + o.SetTypeName("DocumentTemplates$GridSortItem") + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 0) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 1) + o.sortOrder = property.NewEnum[string]("SortOrder") + o.sortOrder.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.attributePath, o.attributeRef, o.sortOrder}) + return o +} + +// NewGridSortItem creates a new GridSortItem for user code. Marked dirty (bit 63 = new element). +func NewGridSortItem() *GridSortItem { + o := initGridSortItem() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initHeader creates a Header with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initHeader() *Header { + o := &Header{} + o.SetTypeName("DocumentTemplates$Header") + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 0) + o.topMargin = property.NewPrimitive[float64]("TopMargin", property.DecodeFloat64) + o.topMargin.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.widget, o.topMargin}) + return o +} + +// NewHeader creates a new Header for user code. Marked dirty (bit 63 = new element). +func NewHeader() *Header { + o := initHeader() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLineBreak creates a LineBreak with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLineBreak() *LineBreak { + o := &LineBreak{} + o.SetTypeName("DocumentTemplates$LineBreak") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.name}) + return o +} + +// NewLineBreak creates a new LineBreak for user code. Marked dirty (bit 63 = new element). +func NewLineBreak() *LineBreak { + o := initLineBreak() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPageBreak creates a PageBreak with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPageBreak() *PageBreak { + o := &PageBreak{} + o.SetTypeName("DocumentTemplates$PageBreak") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.name}) + return o +} + +// NewPageBreak creates a new PageBreak for user code. Marked dirty (bit 63 = new element). +func NewPageBreak() *PageBreak { + o := initPageBreak() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStaticImageViewer creates a StaticImageViewer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStaticImageViewer() *StaticImageViewer { + o := &StaticImageViewer{} + o.SetTypeName("DocumentTemplates$StaticImageViewer") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.image = property.NewByNameRef[element.Element]("Image", "Images$Image") + o.image.Bind(&o.Base, 1) + o.width = property.NewPrimitive[int32]("Width", property.DecodeInt32) + o.width.Bind(&o.Base, 2) + o.height = property.NewPrimitive[int32]("Height", property.DecodeInt32) + o.height.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.name, o.image, o.width, o.height}) + return o +} + +// NewStaticImageViewer creates a new StaticImageViewer for user code. Marked dirty (bit 63 = new element). +func NewStaticImageViewer() *StaticImageViewer { + o := initStaticImageViewer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStaticLabel creates a StaticLabel with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStaticLabel() *StaticLabel { + o := &StaticLabel{} + o.SetTypeName("DocumentTemplates$StaticLabel") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.style = property.NewPart[element.Element]("Style") + o.style.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.caption, o.style}) + return o +} + +// NewStaticLabel creates a new StaticLabel for user code. Marked dirty (bit 63 = new element). +func NewStaticLabel() *StaticLabel { + o := initStaticLabel() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStyle creates a Style with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStyle() *Style { + o := &Style{} + o.SetTypeName("DocumentTemplates$Style") + o.fontFamily = property.NewEnum[string]("FontFamily") + o.fontFamily.Bind(&o.Base, 0) + o.fontSize = property.NewPrimitive[int32]("FontSize", property.DecodeInt32) + o.fontSize.Bind(&o.Base, 1) + o.bold = property.NewPrimitive[bool]("Bold", property.DecodeBool) + o.bold.Bind(&o.Base, 2) + o.italic = property.NewPrimitive[bool]("Italic", property.DecodeBool) + o.italic.Bind(&o.Base, 3) + o.fontColor = property.NewPrimitive[string]("FontColor", property.DecodeString) + o.fontColor.Bind(&o.Base, 4) + o.backgroundColor = property.NewPrimitive[string]("BackgroundColor", property.DecodeString) + o.backgroundColor.Bind(&o.Base, 5) + o.overrideFontFamily = property.NewPrimitive[bool]("OverrideFontFamily", property.DecodeBool) + o.overrideFontFamily.Bind(&o.Base, 6) + o.overrideFontSize = property.NewPrimitive[bool]("OverrideFontSize", property.DecodeBool) + o.overrideFontSize.Bind(&o.Base, 7) + o.overrideBold = property.NewPrimitive[bool]("OverrideBold", property.DecodeBool) + o.overrideBold.Bind(&o.Base, 8) + o.overrideItalic = property.NewPrimitive[bool]("OverrideItalic", property.DecodeBool) + o.overrideItalic.Bind(&o.Base, 9) + o.overrideFontColor = property.NewPrimitive[bool]("OverrideFontColor", property.DecodeBool) + o.overrideFontColor.Bind(&o.Base, 10) + o.overrideBackgroundColor = property.NewPrimitive[bool]("OverrideBackgroundColor", property.DecodeBool) + o.overrideBackgroundColor.Bind(&o.Base, 11) + o.borderStyleTop = property.NewEnum[string]("BorderStyleTop") + o.borderStyleTop.Bind(&o.Base, 12) + o.borderStyleBottom = property.NewEnum[string]("BorderStyleBottom") + o.borderStyleBottom.Bind(&o.Base, 13) + o.borderStyleLeft = property.NewEnum[string]("BorderStyleLeft") + o.borderStyleLeft.Bind(&o.Base, 14) + o.borderStyleRight = property.NewEnum[string]("BorderStyleRight") + o.borderStyleRight.Bind(&o.Base, 15) + o.borderWidthTop = property.NewPrimitive[int32]("BorderWidthTop", property.DecodeInt32) + o.borderWidthTop.Bind(&o.Base, 16) + o.borderWidthBottom = property.NewPrimitive[int32]("BorderWidthBottom", property.DecodeInt32) + o.borderWidthBottom.Bind(&o.Base, 17) + o.borderWidthLeft = property.NewPrimitive[int32]("BorderWidthLeft", property.DecodeInt32) + o.borderWidthLeft.Bind(&o.Base, 18) + o.borderWidthRight = property.NewPrimitive[int32]("BorderWidthRight", property.DecodeInt32) + o.borderWidthRight.Bind(&o.Base, 19) + o.borderColorTop = property.NewPrimitive[string]("BorderColorTop", property.DecodeString) + o.borderColorTop.Bind(&o.Base, 20) + o.borderColorBottom = property.NewPrimitive[string]("BorderColorBottom", property.DecodeString) + o.borderColorBottom.Bind(&o.Base, 21) + o.borderColorLeft = property.NewPrimitive[string]("BorderColorLeft", property.DecodeString) + o.borderColorLeft.Bind(&o.Base, 22) + o.borderColorRight = property.NewPrimitive[string]("BorderColorRight", property.DecodeString) + o.borderColorRight.Bind(&o.Base, 23) + o.textAlign = property.NewEnum[string]("TextAlign") + o.textAlign.Bind(&o.Base, 24) + o.customStyles = property.NewPrimitive[string]("CustomStyles", property.DecodeString) + o.customStyles.Bind(&o.Base, 25) + o.SetProperties([]element.Property{o.fontFamily, o.fontSize, o.bold, o.italic, o.fontColor, o.backgroundColor, o.overrideFontFamily, o.overrideFontSize, o.overrideBold, o.overrideItalic, o.overrideFontColor, o.overrideBackgroundColor, o.borderStyleTop, o.borderStyleBottom, o.borderStyleLeft, o.borderStyleRight, o.borderWidthTop, o.borderWidthBottom, o.borderWidthLeft, o.borderWidthRight, o.borderColorTop, o.borderColorBottom, o.borderColorLeft, o.borderColorRight, o.textAlign, o.customStyles}) + return o +} + +// NewStyle creates a new Style for user code. Marked dirty (bit 63 = new element). +func NewStyle() *Style { + o := initStyle() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTable creates a Table with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTable() *Table { + o := &Table{} + o.SetTypeName("DocumentTemplates$Table") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.rows = property.NewPartList[element.Element]("Rows") + o.rows.Bind(&o.Base, 1) + o.columnWeights = property.NewPrimitive[string]("ColumnWeights", property.DecodeString) + o.columnWeights.Bind(&o.Base, 2) + o.cellSpacing = property.NewPrimitive[int32]("CellSpacing", property.DecodeInt32) + o.cellSpacing.Bind(&o.Base, 3) + o.cellPadding = property.NewPrimitive[int32]("CellPadding", property.DecodeInt32) + o.cellPadding.Bind(&o.Base, 4) + o.style = property.NewPart[element.Element]("Style") + o.style.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.rows, o.columnWeights, o.cellSpacing, o.cellPadding, o.style}) + return o +} + +// NewTable creates a new Table for user code. Marked dirty (bit 63 = new element). +func NewTable() *Table { + o := initTable() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTableCell creates a TableCell with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTableCell() *TableCell { + o := &TableCell{} + o.SetTypeName("DocumentTemplates$TableCell") + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 0) + o.colSpan = property.NewPrimitive[int32]("ColSpan", property.DecodeInt32) + o.colSpan.Bind(&o.Base, 1) + o.rowSpan = property.NewPrimitive[int32]("RowSpan", property.DecodeInt32) + o.rowSpan.Bind(&o.Base, 2) + o.isPartOfSpan = property.NewPrimitive[bool]("IsPartOfSpan", property.DecodeBool) + o.isPartOfSpan.Bind(&o.Base, 3) + o.style = property.NewPart[element.Element]("Style") + o.style.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.widget, o.colSpan, o.rowSpan, o.isPartOfSpan, o.style}) + return o +} + +// NewTableCell creates a new TableCell for user code. Marked dirty (bit 63 = new element). +func NewTableCell() *TableCell { + o := initTableCell() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTableRow creates a TableRow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTableRow() *TableRow { + o := &TableRow{} + o.SetTypeName("DocumentTemplates$TableRow") + o.cells = property.NewPartList[element.Element]("Cells") + o.cells.Bind(&o.Base, 0) + o.conditionSettings = property.NewPart[element.Element]("ConditionSettings") + o.conditionSettings.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.cells, o.conditionSettings}) + return o +} + +// NewTableRow creates a new TableRow for user code. Marked dirty (bit 63 = new element). +func NewTableRow() *TableRow { + o := initTableRow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTemplateGrid creates a TemplateGrid with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTemplateGrid() *TemplateGrid { + o := &TemplateGrid{} + o.SetTypeName("DocumentTemplates$TemplateGrid") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.cellSpacing = property.NewPrimitive[int32]("CellSpacing", property.DecodeInt32) + o.cellSpacing.Bind(&o.Base, 3) + o.cellPadding = property.NewPrimitive[int32]("CellPadding", property.DecodeInt32) + o.cellPadding.Bind(&o.Base, 4) + o.style = property.NewPart[element.Element]("Style") + o.style.Bind(&o.Base, 5) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 6) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 7) + o.numberOfColumns = property.NewPrimitive[int32]("NumberOfColumns", property.DecodeInt32) + o.numberOfColumns.Bind(&o.Base, 8) + o.oddRowsContents = property.NewPart[element.Element]("OddRowsContents") + o.oddRowsContents.Bind(&o.Base, 9) + o.evenRowsContents = property.NewPart[element.Element]("EvenRowsContents") + o.evenRowsContents.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.entityPath, o.entityRef, o.cellSpacing, o.cellPadding, o.style, o.sortBar, o.microflow, o.numberOfColumns, o.oddRowsContents, o.evenRowsContents}) + return o +} + +// NewTemplateGrid creates a new TemplateGrid for user code. Marked dirty (bit 63 = new element). +func NewTemplateGrid() *TemplateGrid { + o := initTemplateGrid() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTemplateGridContents creates a TemplateGridContents with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTemplateGridContents() *TemplateGridContents { + o := &TemplateGridContents{} + o.SetTypeName("DocumentTemplates$TemplateGridContents") + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.widget}) + return o +} + +// NewTemplateGridContents creates a new TemplateGridContents for user code. Marked dirty (bit 63 = new element). +func NewTemplateGridContents() *TemplateGridContents { + o := initTemplateGridContents() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTitle creates a Title with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTitle() *Title { + o := &Title{} + o.SetTypeName("DocumentTemplates$Title") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.style = property.NewPart[element.Element]("Style") + o.style.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.caption, o.style}) + return o +} + +// NewTitle creates a new Title for user code. Marked dirty (bit 63 = new element). +func NewTitle() *Title { + o := initTitle() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("DocumentTemplates$ConditionSettings", func() element.Element { + return initConditionSettings() + }) + codec.DefaultRegistry.Register("DocumentTemplates$DataGrid", func() element.Element { + return initDataGrid() + }) + codec.DefaultRegistry.Register("DocumentTemplates$DataGridCell", func() element.Element { + return initDataGridCell() + }) + codec.DefaultRegistry.Register("DocumentTemplates$DataGridColumn", func() element.Element { + o := initDataGridColumn() + o.SetTypeName("DocumentTemplates$DataGridColumn") + return o + }) + codec.DefaultRegistry.Register("Forms$DataGridColumn", func() element.Element { + return initDataGridColumn() + }) + codec.DefaultRegistry.Register("DocumentTemplates$DataView", func() element.Element { + return initDataView() + }) + codec.DefaultRegistry.Register("DocumentTemplates$DataViewContents", func() element.Element { + return initDataViewContents() + }) + codec.DefaultRegistry.Register("DocumentTemplates$DocumentTemplate", func() element.Element { + return initDocumentTemplate() + }) + codec.DefaultRegistry.Register("DocumentTemplates$DynamicImageViewer", func() element.Element { + return initDynamicImageViewer() + }) + codec.DefaultRegistry.Register("DocumentTemplates$DynamicLabel", func() element.Element { + return initDynamicLabel() + }) + codec.DefaultRegistry.Register("DocumentTemplates$Footer", func() element.Element { + return initFooter() + }) + codec.DefaultRegistry.Register("DocumentTemplates$GridSortBar", func() element.Element { + return initGridSortBar() + }) + codec.DefaultRegistry.Register("DocumentTemplates$GridSortItem", func() element.Element { + return initGridSortItem() + }) + codec.DefaultRegistry.Register("DocumentTemplates$Header", func() element.Element { + return initHeader() + }) + codec.DefaultRegistry.Register("DocumentTemplates$LineBreak", func() element.Element { + return initLineBreak() + }) + codec.DefaultRegistry.Register("DocumentTemplates$PageBreak", func() element.Element { + return initPageBreak() + }) + codec.DefaultRegistry.Register("DocumentTemplates$StaticImageViewer", func() element.Element { + return initStaticImageViewer() + }) + codec.DefaultRegistry.Register("DocumentTemplates$StaticLabel", func() element.Element { + return initStaticLabel() + }) + codec.DefaultRegistry.Register("DocumentTemplates$Style", func() element.Element { + return initStyle() + }) + codec.DefaultRegistry.Register("DocumentTemplates$Table", func() element.Element { + return initTable() + }) + codec.DefaultRegistry.Register("DocumentTemplates$TableCell", func() element.Element { + return initTableCell() + }) + codec.DefaultRegistry.Register("DocumentTemplates$TableRow", func() element.Element { + return initTableRow() + }) + codec.DefaultRegistry.Register("DocumentTemplates$TemplateGrid", func() element.Element { + return initTemplateGrid() + }) + codec.DefaultRegistry.Register("DocumentTemplates$TemplateGridContents", func() element.Element { + return initTemplateGridContents() + }) + codec.DefaultRegistry.Register("DocumentTemplates$Title", func() element.Element { + return initTitle() + }) +} diff --git a/modelsdk/gen/documenttemplates/version.go b/modelsdk/gen/documenttemplates/version.go new file mode 100644 index 00000000..72259aac --- /dev/null +++ b/modelsdk/gen/documenttemplates/version.go @@ -0,0 +1,120 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package documenttemplates + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "DocumentTemplates$AttributeWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "attributePath": {Deleted: "7.11.0"}, + "attributeRef": {Introduced: "7.11.0"}, + }, + }, + "DocumentTemplates$EntityWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "entityPath": {Deleted: "7.11.0"}, + "entityRef": {Introduced: "7.11.0"}, + }, + }, + "DocumentTemplates$Grid": { + Properties: map[string]version.PropertyVersionInfo{ + "sortBar": {Required: true}, + "style": {Required: true}, + }, + }, + "DocumentTemplates$DataGridCell": { + Properties: map[string]version.PropertyVersionInfo{ + "style": {Required: true}, + }, + }, + "DocumentTemplates$DataGridColumn": { + Properties: map[string]version.PropertyVersionInfo{ + "attributePath": {Deleted: "7.11.0"}, + "attributeRef": {Introduced: "7.11.0"}, + "caption": {Required: true}, + "formattingInfo": {Required: true}, + "oddRowsCell": {Required: true}, + "style": {Required: true}, + }, + }, + "Forms$DataGridColumn": { + Properties: map[string]version.PropertyVersionInfo{ + "attributePath": {Deleted: "7.11.0"}, + "attributeRef": {Introduced: "7.11.0"}, + "caption": {Required: true}, + "formattingInfo": {Required: true}, + "oddRowsCell": {Required: true}, + "style": {Required: true}, + }, + }, + "DocumentTemplates$DataView": { + Properties: map[string]version.PropertyVersionInfo{ + "contents": {Required: true}, + }, + }, + "DocumentTemplates$DocumentTemplate": { + Properties: map[string]version.PropertyVersionInfo{ + "style": {Required: true}, + }, + }, + "DocumentTemplates$DocumentTemplateParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "parameterType": {Introduced: "7.9.0", Required: true, Public: true}, + "type": {Deleted: "7.9.0", Public: true}, + }, + }, + "DocumentTemplates$DynamicLabel": { + Properties: map[string]version.PropertyVersionInfo{ + "formattingInfo": {Required: true}, + "style": {Required: true}, + }, + }, + "DocumentTemplates$GridSortItem": { + Properties: map[string]version.PropertyVersionInfo{ + "attributePath": {Deleted: "7.11.0"}, + "attributeRef": {Introduced: "7.11.0", Required: true}, + }, + }, + "DocumentTemplates$StaticLabel": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + "style": {Required: true}, + }, + }, + "DocumentTemplates$Style": { + Properties: map[string]version.PropertyVersionInfo{ + "fontFamily": {}, + }, + }, + "DocumentTemplates$Table": { + Properties: map[string]version.PropertyVersionInfo{ + "style": {Required: true}, + }, + }, + "DocumentTemplates$TableCell": { + Properties: map[string]version.PropertyVersionInfo{ + "style": {Required: true}, + }, + }, + "DocumentTemplates$TableRow": { + Properties: map[string]version.PropertyVersionInfo{ + "conditionSettings": {Required: true}, + }, + }, + "DocumentTemplates$TemplateGrid": { + Properties: map[string]version.PropertyVersionInfo{ + "oddRowsContents": {Required: true}, + }, + }, + "DocumentTemplates$Title": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + "style": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/domainmodels/enums.go b/modelsdk/gen/domainmodels/enums.go new file mode 100644 index 00000000..1b0c3848 --- /dev/null +++ b/modelsdk/gen/domainmodels/enums.go @@ -0,0 +1,110 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package domainmodels + +// ActionMoment enumerates the possible values for the ActionMoment type. +type ActionMoment = string + +const ( + ActionMomentBefore ActionMoment = "Before" + ActionMomentAfter ActionMoment = "After" +) + +// AssociationNavigability enumerates the possible values for the AssociationNavigability type. +type AssociationNavigability = string + +const ( + AssociationNavigabilityBothDirections AssociationNavigability = "BothDirections" + AssociationNavigabilityParentToChild AssociationNavigability = "ParentToChild" + AssociationNavigabilityChildToParent AssociationNavigability = "ChildToParent" +) + +// AssociationOwner enumerates the possible values for the AssociationOwner type. +type AssociationOwner = string + +const ( + AssociationOwnerDefault AssociationOwner = "Default" + AssociationOwnerBoth AssociationOwner = "Both" +) + +// AssociationStorage enumerates the possible values for the AssociationStorage type. +type AssociationStorage = string + +const ( + AssociationStorageTable AssociationStorage = "Table" + AssociationStorageColumn AssociationStorage = "Column" +) + +// AssociationType enumerates the possible values for the AssociationType type. +type AssociationType = string + +const ( + AssociationTypeReference AssociationType = "Reference" + AssociationTypeReferenceSet AssociationType = "ReferenceSet" +) + +// DeletingBehavior enumerates the possible values for the DeletingBehavior type. +type DeletingBehavior = string + +const ( + DeletingBehaviorDeleteMeAndReferences DeletingBehavior = "DeleteMeAndReferences" + DeletingBehaviorDeleteMeButKeepReferences DeletingBehavior = "DeleteMeButKeepReferences" + DeletingBehaviorDeleteMeIfNoReferences DeletingBehavior = "DeleteMeIfNoReferences" +) + +// EnvironmentType enumerates the possible values for the EnvironmentType type. +type EnvironmentType = string + +const ( + EnvironmentTypeProduction EnvironmentType = "Production" + EnvironmentTypeSandbox EnvironmentType = "Sandbox" + EnvironmentTypeNonProduction EnvironmentType = "NonProduction" + EnvironmentTypeUnknown EnvironmentType = "Unknown" +) + +// EventType enumerates the possible values for the EventType type. +type EventType = string + +const ( + EventTypeCreate EventType = "Create" + EventTypeCommit EventType = "Commit" + EventTypeDelete EventType = "Delete" + EventTypeRollBack EventType = "RollBack" +) + +// IndexedAttributeType enumerates the possible values for the IndexedAttributeType type. +type IndexedAttributeType = string + +const ( + IndexedAttributeTypeNormal IndexedAttributeType = "Normal" + IndexedAttributeTypeCreatedDate IndexedAttributeType = "CreatedDate" + IndexedAttributeTypeChangedDate IndexedAttributeType = "ChangedDate" +) + +// MemberAccessRights enumerates the possible values for the MemberAccessRights type. +type MemberAccessRights = string + +const ( + MemberAccessRightsNone MemberAccessRights = "None" + MemberAccessRightsReadOnly MemberAccessRights = "ReadOnly" + MemberAccessRightsReadWrite MemberAccessRights = "ReadWrite" +) + +// Navigability enumerates the possible values for the Navigability type. +type Navigability = string + +const ( + NavigabilityBothDirections Navigability = "BothDirections" + NavigabilityParentToChild Navigability = "ParentToChild" +) + +// RangeType enumerates the possible values for the RangeType type. +type RangeType = string + +const ( + RangeTypeGreaterThanOrEqualTo RangeType = "GreaterThanOrEqualTo" + RangeTypeSmallerThanOrEqualTo RangeType = "SmallerThanOrEqualTo" + RangeTypeBetween RangeType = "Between" +) diff --git a/modelsdk/gen/domainmodels/refs.go b/modelsdk/gen/domainmodels/refs.go new file mode 100644 index 00000000..efb68f0c --- /dev/null +++ b/modelsdk/gen/domainmodels/refs.go @@ -0,0 +1,86 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package domainmodels + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("DomainModels$AccessRule", []codec.RefMeta{ + {Prop: "ModuleRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$AssociationBase", []codec.RefMeta{ + {Prop: "Parent", Kind: codec.RefById, Target: ""}, + {Prop: "RemoteSourceDocument", Kind: codec.RefByName, Target: "DomainModels$RemoteEntitySourceDocument"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$Association", []codec.RefMeta{ + {Prop: "ParentPointer", Kind: codec.RefById, Target: ""}, + {Prop: "RemoteSourceDocument", Kind: codec.RefByName, Target: "DomainModels$RemoteEntitySourceDocument"}, + {Prop: "ChildPointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$AssociationRef", []codec.RefMeta{ + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$AttributeRef", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$CalculatedValue", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$CrossAssociation", []codec.RefMeta{ + {Prop: "ParentPointer", Kind: codec.RefById, Target: ""}, + {Prop: "RemoteSourceDocument", Kind: codec.RefByName, Target: "DomainModels$RemoteEntitySourceDocument"}, + {Prop: "Child", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$DirectEntityRef", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$Entity", []codec.RefMeta{ + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + {Prop: "RemoteSourceDocument", Kind: codec.RefByName, Target: "DomainModels$RemoteEntitySourceDocument"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$EntityImpl", []codec.RefMeta{ + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + {Prop: "RemoteSourceDocument", Kind: codec.RefByName, Target: "DomainModels$RemoteEntitySourceDocument"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$EntityRefStep", []codec.RefMeta{ + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + {Prop: "DestinationEntity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$EnumerationAttributeType", []codec.RefMeta{ + {Prop: "Enumeration", Kind: codec.RefByName, Target: "Enumerations$Enumeration"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$EqualsToRuleInfo", []codec.RefMeta{ + {Prop: "EqualsToAttribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$EventHandler", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$EntityEvent", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$Generalization", []codec.RefMeta{ + {Prop: "Generalization", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$IndexedAttribute", []codec.RefMeta{ + {Prop: "AttributePointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$MemberAccess", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$OqlViewEntitySource", []codec.RefMeta{ + {Prop: "SourceDocument", Kind: codec.RefByName, Target: "DomainModels$ViewEntitySourceDocument"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$RangeRuleInfo", []codec.RefMeta{ + {Prop: "MinAttribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "MaxAttribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$RegExRuleInfo", []codec.RefMeta{ + {Prop: "RegularExpression", Kind: codec.RefByName, Target: "RegularExpressions$RegularExpression"}, + }) + codec.DefaultRefRegistry.RegisterRefs("DomainModels$ValidationRule", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) +} diff --git a/modelsdk/gen/domainmodels/types.go b/modelsdk/gen/domainmodels/types.go new file mode 100644 index 00000000..bde14202 --- /dev/null +++ b/modelsdk/gen/domainmodels/types.go @@ -0,0 +1,4757 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package domainmodels + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// AccessRule +// ──────────────────────────────────────────────────────── + +type AccessRule struct { + element.Base + memberAccesses *property.PartList[element.Element] + moduleRoles *property.ByNameRefList[element.Element] + documentation *property.Primitive[string] + allowCreate *property.Primitive[bool] + allowDelete *property.Primitive[bool] + defaultMemberAccessRights *property.Enum[string] + xPathConstraintCaption *property.Primitive[string] + xPathConstraint *property.Primitive[string] +} + +// MemberAccessesItems returns the value of the memberAccesses property. +func (o *AccessRule) MemberAccessesItems() []element.Element { + return o.memberAccesses.Items() +} + +// AddMemberAccesses appends a child element to the memberAccesses list. +func (o *AccessRule) AddMemberAccesses(v element.Element) { + o.memberAccesses.Append(v) +} + +// RemoveMemberAccesses removes the element at the given index from the memberAccesses list. +func (o *AccessRule) RemoveMemberAccesses(index int) { + o.memberAccesses.Remove(index) +} + +// ModuleRolesQualifiedNames returns the value of the moduleRoles property. +func (o *AccessRule) ModuleRolesQualifiedNames() []string { + return o.moduleRoles.QualifiedNames() +} + +// SetModuleRolesQualifiedNames sets the value of the moduleRoles property. +func (o *AccessRule) SetModuleRolesQualifiedNames(v []string) { + o.moduleRoles.SetQualifiedNames(v) +} + +// AddModuleRoles appends a child element to the moduleRoles list. +func (o *AccessRule) AddModuleRoles(v string) { + o.moduleRoles.Append(v) +} + +// Documentation returns the value of the documentation property. +func (o *AccessRule) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *AccessRule) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// AllowCreate returns the value of the allowCreate property. +func (o *AccessRule) AllowCreate() bool { + return o.allowCreate.Get() +} + +// SetAllowCreate sets the value of the allowCreate property. +func (o *AccessRule) SetAllowCreate(v bool) { + o.allowCreate.Set(v) +} + +// AllowDelete returns the value of the allowDelete property. +func (o *AccessRule) AllowDelete() bool { + return o.allowDelete.Get() +} + +// SetAllowDelete sets the value of the allowDelete property. +func (o *AccessRule) SetAllowDelete(v bool) { + o.allowDelete.Set(v) +} + +// DefaultMemberAccessRights returns the value of the defaultMemberAccessRights property. +func (o *AccessRule) DefaultMemberAccessRights() string { + return o.defaultMemberAccessRights.Get() +} + +// SetDefaultMemberAccessRights sets the value of the defaultMemberAccessRights property. +func (o *AccessRule) SetDefaultMemberAccessRights(v string) { + o.defaultMemberAccessRights.Set(v) +} + +// XPathConstraintCaption returns the value of the xPathConstraintCaption property. +func (o *AccessRule) XPathConstraintCaption() string { + return o.xPathConstraintCaption.Get() +} + +// SetXPathConstraintCaption sets the value of the xPathConstraintCaption property. +func (o *AccessRule) SetXPathConstraintCaption(v string) { + o.xPathConstraintCaption.Set(v) +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *AccessRule) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *AccessRule) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AccessRule) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "MemberAccesses"); err == nil { + for _, child := range children { + o.memberAccesses.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("ModuleRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { + qnames = append(qnames, s) + } + } + o.moduleRoles.SetFromDecode(qnames) + } + } + o.documentation.Init(raw) + o.allowCreate.Init(raw) + o.allowDelete.Init(raw) + if val, err := raw.LookupErr("DefaultMemberAccessRights"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.defaultMemberAccessRights.SetFromDecode(s) + } + } + o.xPathConstraintCaption.Init(raw) + o.xPathConstraint.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Annotation +// ──────────────────────────────────────────────────────── + +type Annotation struct { + element.Base + caption *property.Primitive[string] + location *property.Primitive[string] + width *property.Primitive[int32] + exportLevel *property.Enum[string] +} + +// Caption returns the value of the caption property. +func (o *Annotation) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *Annotation) SetCaption(v string) { + o.caption.Set(v) +} + +// Location returns the value of the location property. +func (o *Annotation) Location() string { + return o.location.Get() +} + +// SetLocation sets the value of the location property. +func (o *Annotation) SetLocation(v string) { + o.location.Set(v) +} + +// Width returns the value of the width property. +func (o *Annotation) Width() int32 { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *Annotation) SetWidth(v int32) { + o.width.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Annotation) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Annotation) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Annotation) InitFromRaw(raw bson.Raw) { + o.caption.Init(raw) + o.location.Init(raw) + o.width.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// AssociationBase +// ──────────────────────────────────────────────────────── + +type AssociationBase struct { + element.Base + name *property.Primitive[string] + dataStorageGuid *property.Primitive[string] + propType *property.Enum[string] + owner *property.Enum[string] + storageFormat *property.Enum[string] + deleteBehavior *property.Part[element.Element] + parent *property.ByIdRef[element.Element] + documentation *property.Primitive[string] + remoteSourceDocument *property.ByNameRef[element.Element] + source *property.Part[element.Element] + capabilities *property.Part[element.Element] + exportLevel *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *AssociationBase) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *AssociationBase) SetName(v string) { + o.name.Set(v) +} + +// DataStorageGuid returns the value of the dataStorageGuid property. +func (o *AssociationBase) DataStorageGuid() string { + return o.dataStorageGuid.Get() +} + +// SetDataStorageGuid sets the value of the dataStorageGuid property. +func (o *AssociationBase) SetDataStorageGuid(v string) { + o.dataStorageGuid.Set(v) +} + +// Type returns the value of the type property. +func (o *AssociationBase) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *AssociationBase) SetType(v string) { + o.propType.Set(v) +} + +// Owner returns the value of the owner property. +func (o *AssociationBase) Owner() string { + return o.owner.Get() +} + +// SetOwner sets the value of the owner property. +func (o *AssociationBase) SetOwner(v string) { + o.owner.Set(v) +} + +// StorageFormat returns the value of the storageFormat property. +func (o *AssociationBase) StorageFormat() string { + return o.storageFormat.Get() +} + +// SetStorageFormat sets the value of the storageFormat property. +func (o *AssociationBase) SetStorageFormat(v string) { + o.storageFormat.Set(v) +} + +// DeleteBehavior returns the value of the deleteBehavior property. +func (o *AssociationBase) DeleteBehavior() element.Element { + return o.deleteBehavior.Get() +} + +// SetDeleteBehavior sets the value of the deleteBehavior property. +func (o *AssociationBase) SetDeleteBehavior(v element.Element) { + o.deleteBehavior.Set(v) +} + +// ParentRefID returns the value of the parent property. +func (o *AssociationBase) ParentRefID() element.ID { + return o.parent.RefID() +} + +// SetParentID sets the value of the parent property. +func (o *AssociationBase) SetParentID(v element.ID) { + o.parent.SetID(v) +} + +// Documentation returns the value of the documentation property. +func (o *AssociationBase) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *AssociationBase) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// RemoteSourceDocumentQualifiedName returns the value of the remoteSourceDocument property. +func (o *AssociationBase) RemoteSourceDocumentQualifiedName() string { + return o.remoteSourceDocument.QualifiedName() +} + +// SetRemoteSourceDocumentQualifiedName sets the value of the remoteSourceDocument property. +func (o *AssociationBase) SetRemoteSourceDocumentQualifiedName(v string) { + o.remoteSourceDocument.SetQualifiedName(v) +} + +// Source returns the value of the source property. +func (o *AssociationBase) Source() element.Element { + return o.source.Get() +} + +// SetSource sets the value of the source property. +func (o *AssociationBase) SetSource(v element.Element) { + o.source.Set(v) +} + +// Capabilities returns the value of the capabilities property. +func (o *AssociationBase) Capabilities() element.Element { + return o.capabilities.Get() +} + +// SetCapabilities sets the value of the capabilities property. +func (o *AssociationBase) SetCapabilities(v element.Element) { + o.capabilities.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *AssociationBase) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *AssociationBase) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AssociationBase) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.dataStorageGuid.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Owner"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.owner.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("StorageFormat"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.storageFormat.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "DeleteBehavior"); err == nil { + o.deleteBehavior.SetFromDecode(child) + } + if val, err := raw.LookupErr("Parent"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parent.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.parent.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.documentation.Init(raw) + if val, err := raw.LookupErr("RemoteSourceDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.remoteSourceDocument.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Source"); err == nil { + o.source.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Capabilities"); err == nil { + o.capabilities.SetFromDecode(child) + } + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// Association +// ──────────────────────────────────────────────────────── + +type Association struct { + element.Base + name *property.Primitive[string] + dataStorageGuid *property.Primitive[string] + propType *property.Enum[string] + owner *property.Enum[string] + storageFormat *property.Enum[string] + deleteBehavior *property.Part[element.Element] + parent *property.ByIdRef[element.Element] + documentation *property.Primitive[string] + remoteSourceDocument *property.ByNameRef[element.Element] + source *property.Part[element.Element] + capabilities *property.Part[element.Element] + exportLevel *property.Enum[string] + child *property.ByIdRef[element.Element] + parentConnection *property.Primitive[string] + childConnection *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *Association) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Association) SetName(v string) { + o.name.Set(v) +} + +// DataStorageGuid returns the value of the dataStorageGuid property. +func (o *Association) DataStorageGuid() string { + return o.dataStorageGuid.Get() +} + +// SetDataStorageGuid sets the value of the dataStorageGuid property. +func (o *Association) SetDataStorageGuid(v string) { + o.dataStorageGuid.Set(v) +} + +// Type returns the value of the type property. +func (o *Association) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *Association) SetType(v string) { + o.propType.Set(v) +} + +// Owner returns the value of the owner property. +func (o *Association) Owner() string { + return o.owner.Get() +} + +// SetOwner sets the value of the owner property. +func (o *Association) SetOwner(v string) { + o.owner.Set(v) +} + +// StorageFormat returns the value of the storageFormat property. +func (o *Association) StorageFormat() string { + return o.storageFormat.Get() +} + +// SetStorageFormat sets the value of the storageFormat property. +func (o *Association) SetStorageFormat(v string) { + o.storageFormat.Set(v) +} + +// DeleteBehavior returns the value of the deleteBehavior property. +func (o *Association) DeleteBehavior() element.Element { + return o.deleteBehavior.Get() +} + +// SetDeleteBehavior sets the value of the deleteBehavior property. +func (o *Association) SetDeleteBehavior(v element.Element) { + o.deleteBehavior.Set(v) +} + +// ParentRefID returns the value of the parent property. +func (o *Association) ParentRefID() element.ID { + return o.parent.RefID() +} + +// SetParentID sets the value of the parent property. +func (o *Association) SetParentID(v element.ID) { + o.parent.SetID(v) +} + +// Documentation returns the value of the documentation property. +func (o *Association) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Association) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// RemoteSourceDocumentQualifiedName returns the value of the remoteSourceDocument property. +func (o *Association) RemoteSourceDocumentQualifiedName() string { + return o.remoteSourceDocument.QualifiedName() +} + +// SetRemoteSourceDocumentQualifiedName sets the value of the remoteSourceDocument property. +func (o *Association) SetRemoteSourceDocumentQualifiedName(v string) { + o.remoteSourceDocument.SetQualifiedName(v) +} + +// Source returns the value of the source property. +func (o *Association) Source() element.Element { + return o.source.Get() +} + +// SetSource sets the value of the source property. +func (o *Association) SetSource(v element.Element) { + o.source.Set(v) +} + +// Capabilities returns the value of the capabilities property. +func (o *Association) Capabilities() element.Element { + return o.capabilities.Get() +} + +// SetCapabilities sets the value of the capabilities property. +func (o *Association) SetCapabilities(v element.Element) { + o.capabilities.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Association) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Association) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ChildRefID returns the value of the child property. +func (o *Association) ChildRefID() element.ID { + return o.child.RefID() +} + +// SetChildID sets the value of the child property. +func (o *Association) SetChildID(v element.ID) { + o.child.SetID(v) +} + +// ParentConnection returns the value of the parentConnection property. +func (o *Association) ParentConnection() string { + return o.parentConnection.Get() +} + +// SetParentConnection sets the value of the parentConnection property. +func (o *Association) SetParentConnection(v string) { + o.parentConnection.Set(v) +} + +// ChildConnection returns the value of the childConnection property. +func (o *Association) ChildConnection() string { + return o.childConnection.Get() +} + +// SetChildConnection sets the value of the childConnection property. +func (o *Association) SetChildConnection(v string) { + o.childConnection.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Association) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.dataStorageGuid.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Owner"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.owner.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("StorageFormat"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.storageFormat.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "DeleteBehavior"); err == nil { + o.deleteBehavior.SetFromDecode(child) + } + if val, err := raw.LookupErr("ParentPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parent.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.parent.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.documentation.Init(raw) + if val, err := raw.LookupErr("RemoteSourceDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.remoteSourceDocument.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Source"); err == nil { + o.source.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Capabilities"); err == nil { + o.capabilities.SetFromDecode(child) + } + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ChildPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.child.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.child.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.parentConnection.Init(raw) + o.childConnection.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// AssociationCapabilities +// ──────────────────────────────────────────────────────── + +type AssociationCapabilities struct { + element.Base + navigability *property.Enum[string] +} + +// Navigability returns the value of the navigability property. +func (o *AssociationCapabilities) Navigability() string { + return o.navigability.Get() +} + +// SetNavigability sets the value of the navigability property. +func (o *AssociationCapabilities) SetNavigability(v string) { + o.navigability.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AssociationCapabilities) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Navigability"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.navigability.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// AssociationDeleteBehavior +// ──────────────────────────────────────────────────────── + +type AssociationDeleteBehavior struct { + element.Base + parentDeleteBehavior *property.Enum[string] + childDeleteBehavior *property.Enum[string] + parentErrorMessage *property.Part[element.Element] + childErrorMessage *property.Part[element.Element] +} + +// ParentDeleteBehavior returns the value of the parentDeleteBehavior property. +func (o *AssociationDeleteBehavior) ParentDeleteBehavior() string { + return o.parentDeleteBehavior.Get() +} + +// SetParentDeleteBehavior sets the value of the parentDeleteBehavior property. +func (o *AssociationDeleteBehavior) SetParentDeleteBehavior(v string) { + o.parentDeleteBehavior.Set(v) +} + +// ChildDeleteBehavior returns the value of the childDeleteBehavior property. +func (o *AssociationDeleteBehavior) ChildDeleteBehavior() string { + return o.childDeleteBehavior.Get() +} + +// SetChildDeleteBehavior sets the value of the childDeleteBehavior property. +func (o *AssociationDeleteBehavior) SetChildDeleteBehavior(v string) { + o.childDeleteBehavior.Set(v) +} + +// ParentErrorMessage returns the value of the parentErrorMessage property. +func (o *AssociationDeleteBehavior) ParentErrorMessage() element.Element { + return o.parentErrorMessage.Get() +} + +// SetParentErrorMessage sets the value of the parentErrorMessage property. +func (o *AssociationDeleteBehavior) SetParentErrorMessage(v element.Element) { + o.parentErrorMessage.Set(v) +} + +// ChildErrorMessage returns the value of the childErrorMessage property. +func (o *AssociationDeleteBehavior) ChildErrorMessage() element.Element { + return o.childErrorMessage.Get() +} + +// SetChildErrorMessage sets the value of the childErrorMessage property. +func (o *AssociationDeleteBehavior) SetChildErrorMessage(v element.Element) { + o.childErrorMessage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AssociationDeleteBehavior) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ParentDeleteBehavior"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parentDeleteBehavior.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ChildDeleteBehavior"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.childDeleteBehavior.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "ParentErrorMessage"); err == nil { + o.parentErrorMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ChildErrorMessage"); err == nil { + o.childErrorMessage.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MemberRef +// ──────────────────────────────────────────────────────── + +type MemberRef struct { + element.Base + entityRef *property.Part[element.Element] +} + +// EntityRef returns the value of the entityRef property. +func (o *MemberRef) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *MemberRef) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MemberRef) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// AssociationRef +// ──────────────────────────────────────────────────────── + +type AssociationRef struct { + element.Base + entityRef *property.Part[element.Element] + association *property.ByNameRef[element.Element] +} + +// EntityRef returns the value of the entityRef property. +func (o *AssociationRef) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *AssociationRef) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *AssociationRef) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *AssociationRef) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AssociationRef) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.association.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// AssociationSource +// ──────────────────────────────────────────────────────── + +type AssociationSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AssociationSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Attribute +// ──────────────────────────────────────────────────────── + +type Attribute struct { + element.Base + name *property.Primitive[string] + dataStorageGuid *property.Primitive[string] + propType *property.Part[element.Element] + documentation *property.Primitive[string] + value *property.Part[element.Element] + capabilities *property.Part[element.Element] + exportLevel *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *Attribute) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Attribute) SetName(v string) { + o.name.Set(v) +} + +// DataStorageGuid returns the value of the dataStorageGuid property. +func (o *Attribute) DataStorageGuid() string { + return o.dataStorageGuid.Get() +} + +// SetDataStorageGuid sets the value of the dataStorageGuid property. +func (o *Attribute) SetDataStorageGuid(v string) { + o.dataStorageGuid.Set(v) +} + +// Type returns the value of the type property. +func (o *Attribute) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *Attribute) SetType(v element.Element) { + o.propType.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Attribute) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Attribute) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Value returns the value of the value property. +func (o *Attribute) Value() element.Element { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *Attribute) SetValue(v element.Element) { + o.value.Set(v) +} + +// Capabilities returns the value of the capabilities property. +func (o *Attribute) Capabilities() element.Element { + return o.capabilities.Get() +} + +// SetCapabilities sets the value of the capabilities property. +func (o *Attribute) SetCapabilities(v element.Element) { + o.capabilities.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Attribute) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Attribute) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Attribute) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.dataStorageGuid.Init(raw) + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } + o.documentation.Init(raw) + if child, err := codec.DecodeChild(raw, "Value"); err == nil { + o.value.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Capabilities"); err == nil { + o.capabilities.SetFromDecode(child) + } + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// AttributeCapabilities +// ──────────────────────────────────────────────────────── + +type AttributeCapabilities struct { + element.Base + filterable *property.Primitive[bool] + sortable *property.Primitive[bool] +} + +// Filterable returns the value of the filterable property. +func (o *AttributeCapabilities) Filterable() bool { + return o.filterable.Get() +} + +// SetFilterable sets the value of the filterable property. +func (o *AttributeCapabilities) SetFilterable(v bool) { + o.filterable.Set(v) +} + +// Sortable returns the value of the sortable property. +func (o *AttributeCapabilities) Sortable() bool { + return o.sortable.Get() +} + +// SetSortable sets the value of the sortable property. +func (o *AttributeCapabilities) SetSortable(v bool) { + o.sortable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AttributeCapabilities) InitFromRaw(raw bson.Raw) { + o.filterable.Init(raw) + o.sortable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// AttributeRef +// ──────────────────────────────────────────────────────── + +type AttributeRef struct { + element.Base + entityRef *property.Part[element.Element] + attribute *property.ByNameRef[element.Element] +} + +// EntityRef returns the value of the entityRef property. +func (o *AttributeRef) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *AttributeRef) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *AttributeRef) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *AttributeRef) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AttributeRef) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// AttributeType +// ──────────────────────────────────────────────────────── + +type AttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// NumericAttributeTypeBase +// ──────────────────────────────────────────────────────── + +type NumericAttributeTypeBase struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NumericAttributeTypeBase) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// IntegerAttributeTypeBase +// ──────────────────────────────────────────────────────── + +type IntegerAttributeTypeBase struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IntegerAttributeTypeBase) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// AutoNumberAttributeType +// ──────────────────────────────────────────────────────── + +type AutoNumberAttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AutoNumberAttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BinaryAttributeType +// ──────────────────────────────────────────────────────── + +type BinaryAttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BinaryAttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BooleanAttributeType +// ──────────────────────────────────────────────────────── + +type BooleanAttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BooleanAttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ValueType +// ──────────────────────────────────────────────────────── + +type ValueType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ValueType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// MappedValue +// ──────────────────────────────────────────────────────── + +type MappedValue struct { + element.Base + defaultValueDesignTime *property.Primitive[string] +} + +// DefaultValueDesignTime returns the value of the defaultValueDesignTime property. +func (o *MappedValue) DefaultValueDesignTime() string { + return o.defaultValueDesignTime.Get() +} + +// SetDefaultValueDesignTime sets the value of the defaultValueDesignTime property. +func (o *MappedValue) SetDefaultValueDesignTime(v string) { + o.defaultValueDesignTime.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MappedValue) InitFromRaw(raw bson.Raw) { + o.defaultValueDesignTime.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CachedMappedValue +// ──────────────────────────────────────────────────────── + +type CachedMappedValue struct { + element.Base + defaultValueDesignTime *property.Primitive[string] +} + +// DefaultValueDesignTime returns the value of the defaultValueDesignTime property. +func (o *CachedMappedValue) DefaultValueDesignTime() string { + return o.defaultValueDesignTime.Get() +} + +// SetDefaultValueDesignTime sets the value of the defaultValueDesignTime property. +func (o *CachedMappedValue) SetDefaultValueDesignTime(v string) { + o.defaultValueDesignTime.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CachedMappedValue) InitFromRaw(raw bson.Raw) { + o.defaultValueDesignTime.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CalculatedValue +// ──────────────────────────────────────────────────────── + +type CalculatedValue struct { + element.Base + microflow *property.ByNameRef[element.Element] + passEntity *property.Primitive[bool] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *CalculatedValue) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *CalculatedValue) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// PassEntity returns the value of the passEntity property. +func (o *CalculatedValue) PassEntity() bool { + return o.passEntity.Get() +} + +// SetPassEntity sets the value of the passEntity property. +func (o *CalculatedValue) SetPassEntity(v bool) { + o.passEntity.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CalculatedValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + o.passEntity.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CrossAssociation +// ──────────────────────────────────────────────────────── + +type CrossAssociation struct { + element.Base + name *property.Primitive[string] + dataStorageGuid *property.Primitive[string] + propType *property.Enum[string] + owner *property.Enum[string] + storageFormat *property.Enum[string] + deleteBehavior *property.Part[element.Element] + parent *property.ByIdRef[element.Element] + documentation *property.Primitive[string] + remoteSourceDocument *property.ByNameRef[element.Element] + source *property.Part[element.Element] + capabilities *property.Part[element.Element] + exportLevel *property.Enum[string] + child *property.ByNameRef[element.Element] +} + +// Name returns the value of the name property. +func (o *CrossAssociation) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CrossAssociation) SetName(v string) { + o.name.Set(v) +} + +// DataStorageGuid returns the value of the dataStorageGuid property. +func (o *CrossAssociation) DataStorageGuid() string { + return o.dataStorageGuid.Get() +} + +// SetDataStorageGuid sets the value of the dataStorageGuid property. +func (o *CrossAssociation) SetDataStorageGuid(v string) { + o.dataStorageGuid.Set(v) +} + +// Type returns the value of the type property. +func (o *CrossAssociation) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *CrossAssociation) SetType(v string) { + o.propType.Set(v) +} + +// Owner returns the value of the owner property. +func (o *CrossAssociation) Owner() string { + return o.owner.Get() +} + +// SetOwner sets the value of the owner property. +func (o *CrossAssociation) SetOwner(v string) { + o.owner.Set(v) +} + +// StorageFormat returns the value of the storageFormat property. +func (o *CrossAssociation) StorageFormat() string { + return o.storageFormat.Get() +} + +// SetStorageFormat sets the value of the storageFormat property. +func (o *CrossAssociation) SetStorageFormat(v string) { + o.storageFormat.Set(v) +} + +// DeleteBehavior returns the value of the deleteBehavior property. +func (o *CrossAssociation) DeleteBehavior() element.Element { + return o.deleteBehavior.Get() +} + +// SetDeleteBehavior sets the value of the deleteBehavior property. +func (o *CrossAssociation) SetDeleteBehavior(v element.Element) { + o.deleteBehavior.Set(v) +} + +// ParentRefID returns the value of the parent property. +func (o *CrossAssociation) ParentRefID() element.ID { + return o.parent.RefID() +} + +// SetParentID sets the value of the parent property. +func (o *CrossAssociation) SetParentID(v element.ID) { + o.parent.SetID(v) +} + +// Documentation returns the value of the documentation property. +func (o *CrossAssociation) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *CrossAssociation) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// RemoteSourceDocumentQualifiedName returns the value of the remoteSourceDocument property. +func (o *CrossAssociation) RemoteSourceDocumentQualifiedName() string { + return o.remoteSourceDocument.QualifiedName() +} + +// SetRemoteSourceDocumentQualifiedName sets the value of the remoteSourceDocument property. +func (o *CrossAssociation) SetRemoteSourceDocumentQualifiedName(v string) { + o.remoteSourceDocument.SetQualifiedName(v) +} + +// Source returns the value of the source property. +func (o *CrossAssociation) Source() element.Element { + return o.source.Get() +} + +// SetSource sets the value of the source property. +func (o *CrossAssociation) SetSource(v element.Element) { + o.source.Set(v) +} + +// Capabilities returns the value of the capabilities property. +func (o *CrossAssociation) Capabilities() element.Element { + return o.capabilities.Get() +} + +// SetCapabilities sets the value of the capabilities property. +func (o *CrossAssociation) SetCapabilities(v element.Element) { + o.capabilities.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *CrossAssociation) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *CrossAssociation) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ChildQualifiedName returns the value of the child property. +func (o *CrossAssociation) ChildQualifiedName() string { + return o.child.QualifiedName() +} + +// SetChildQualifiedName sets the value of the child property. +func (o *CrossAssociation) SetChildQualifiedName(v string) { + o.child.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CrossAssociation) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.dataStorageGuid.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Owner"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.owner.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("StorageFormat"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.storageFormat.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "DeleteBehavior"); err == nil { + o.deleteBehavior.SetFromDecode(child) + } + if val, err := raw.LookupErr("ParentPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parent.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.parent.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.documentation.Init(raw) + if val, err := raw.LookupErr("RemoteSourceDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.remoteSourceDocument.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Source"); err == nil { + o.source.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Capabilities"); err == nil { + o.capabilities.SetFromDecode(child) + } + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Child"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.child.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// DecimalAttributeTypeBase +// ──────────────────────────────────────────────────────── + +type DecimalAttributeTypeBase struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DecimalAttributeTypeBase) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// FloatAttributeTypeBase +// ──────────────────────────────────────────────────────── + +type FloatAttributeTypeBase struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FloatAttributeTypeBase) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CurrencyAttributeType +// ──────────────────────────────────────────────────────── + +type CurrencyAttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CurrencyAttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// DateTimeAttributeType +// ──────────────────────────────────────────────────────── + +type DateTimeAttributeType struct { + element.Base + localizeDate *property.Primitive[bool] +} + +// LocalizeDate returns the value of the localizeDate property. +func (o *DateTimeAttributeType) LocalizeDate() bool { + return o.localizeDate.Get() +} + +// SetLocalizeDate sets the value of the localizeDate property. +func (o *DateTimeAttributeType) SetLocalizeDate(v bool) { + o.localizeDate.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DateTimeAttributeType) InitFromRaw(raw bson.Raw) { + o.localizeDate.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DecimalAttributeType +// ──────────────────────────────────────────────────────── + +type DecimalAttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DecimalAttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EntityRef +// ──────────────────────────────────────────────────────── + +type EntityRef struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityRef) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// DirectEntityRef +// ──────────────────────────────────────────────────────── + +type DirectEntityRef struct { + element.Base + entity *property.ByNameRef[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *DirectEntityRef) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *DirectEntityRef) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DirectEntityRef) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// DomainModel +// ──────────────────────────────────────────────────────── + +type DomainModel struct { + element.Base + documentation *property.Primitive[string] + entities *property.PartList[element.Element] + annotations *property.PartList[element.Element] + associations *property.PartList[element.Element] + crossAssociations *property.PartList[element.Element] +} + +// Documentation returns the value of the documentation property. +func (o *DomainModel) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *DomainModel) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// EntitiesItems returns the value of the entities property. +func (o *DomainModel) EntitiesItems() []element.Element { + return o.entities.Items() +} + +// AddEntities appends a child element to the entities list. +func (o *DomainModel) AddEntities(v element.Element) { + o.entities.Append(v) +} + +// RemoveEntities removes the element at the given index from the entities list. +func (o *DomainModel) RemoveEntities(index int) { + o.entities.Remove(index) +} + +// AnnotationsItems returns the value of the annotations property. +func (o *DomainModel) AnnotationsItems() []element.Element { + return o.annotations.Items() +} + +// AddAnnotations appends a child element to the annotations list. +func (o *DomainModel) AddAnnotations(v element.Element) { + o.annotations.Append(v) +} + +// RemoveAnnotations removes the element at the given index from the annotations list. +func (o *DomainModel) RemoveAnnotations(index int) { + o.annotations.Remove(index) +} + +// AssociationsItems returns the value of the associations property. +func (o *DomainModel) AssociationsItems() []element.Element { + return o.associations.Items() +} + +// AddAssociations appends a child element to the associations list. +func (o *DomainModel) AddAssociations(v element.Element) { + o.associations.Append(v) +} + +// RemoveAssociations removes the element at the given index from the associations list. +func (o *DomainModel) RemoveAssociations(index int) { + o.associations.Remove(index) +} + +// CrossAssociationsItems returns the value of the crossAssociations property. +func (o *DomainModel) CrossAssociationsItems() []element.Element { + return o.crossAssociations.Items() +} + +// AddCrossAssociations appends a child element to the crossAssociations list. +func (o *DomainModel) AddCrossAssociations(v element.Element) { + o.crossAssociations.Append(v) +} + +// RemoveCrossAssociations removes the element at the given index from the crossAssociations list. +func (o *DomainModel) RemoveCrossAssociations(index int) { + o.crossAssociations.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DomainModel) InitFromRaw(raw bson.Raw) { + o.documentation.Init(raw) + if children, err := codec.DecodeChildren(raw, "Entities"); err == nil { + for _, child := range children { + o.entities.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Annotations"); err == nil { + for _, child := range children { + o.annotations.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Associations"); err == nil { + for _, child := range children { + o.associations.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "CrossAssociations"); err == nil { + for _, child := range children { + o.crossAssociations.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Entity +// ──────────────────────────────────────────────────────── + +type Entity struct { + element.Base + name *property.Primitive[string] + dataStorageGuid *property.Primitive[string] + location *property.Primitive[string] + documentation *property.Primitive[string] + generalization *property.Part[element.Element] + attributes *property.PartList[element.Element] + validationRules *property.PartList[element.Element] + eventHandlers *property.PartList[element.Element] + indexes *property.PartList[element.Element] + accessRules *property.PartList[element.Element] + image *property.ByNameRef[element.Element] + imageData *property.Primitive[string] + isRemote *property.Primitive[bool] + remoteSource *property.Primitive[string] + remoteSourceDocument *property.ByNameRef[element.Element] + source *property.Part[element.Element] + capabilities *property.Part[element.Element] + exportLevel *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *Entity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Entity) SetName(v string) { + o.name.Set(v) +} + +// DataStorageGuid returns the value of the dataStorageGuid property. +func (o *Entity) DataStorageGuid() string { + return o.dataStorageGuid.Get() +} + +// SetDataStorageGuid sets the value of the dataStorageGuid property. +func (o *Entity) SetDataStorageGuid(v string) { + o.dataStorageGuid.Set(v) +} + +// Location returns the value of the location property. +func (o *Entity) Location() string { + return o.location.Get() +} + +// SetLocation sets the value of the location property. +func (o *Entity) SetLocation(v string) { + o.location.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Entity) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Entity) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Generalization returns the value of the generalization property. +func (o *Entity) Generalization() element.Element { + return o.generalization.Get() +} + +// SetGeneralization sets the value of the generalization property. +func (o *Entity) SetGeneralization(v element.Element) { + o.generalization.Set(v) +} + +// AttributesItems returns the value of the attributes property. +func (o *Entity) AttributesItems() []element.Element { + return o.attributes.Items() +} + +// AddAttributes appends a child element to the attributes list. +func (o *Entity) AddAttributes(v element.Element) { + o.attributes.Append(v) +} + +// RemoveAttributes removes the element at the given index from the attributes list. +func (o *Entity) RemoveAttributes(index int) { + o.attributes.Remove(index) +} + +// ValidationRulesItems returns the value of the validationRules property. +func (o *Entity) ValidationRulesItems() []element.Element { + return o.validationRules.Items() +} + +// AddValidationRules appends a child element to the validationRules list. +func (o *Entity) AddValidationRules(v element.Element) { + o.validationRules.Append(v) +} + +// RemoveValidationRules removes the element at the given index from the validationRules list. +func (o *Entity) RemoveValidationRules(index int) { + o.validationRules.Remove(index) +} + +// EventHandlersItems returns the value of the eventHandlers property. +func (o *Entity) EventHandlersItems() []element.Element { + return o.eventHandlers.Items() +} + +// AddEventHandlers appends a child element to the eventHandlers list. +func (o *Entity) AddEventHandlers(v element.Element) { + o.eventHandlers.Append(v) +} + +// RemoveEventHandlers removes the element at the given index from the eventHandlers list. +func (o *Entity) RemoveEventHandlers(index int) { + o.eventHandlers.Remove(index) +} + +// IndexesItems returns the value of the indexes property. +func (o *Entity) IndexesItems() []element.Element { + return o.indexes.Items() +} + +// AddIndexes appends a child element to the indexes list. +func (o *Entity) AddIndexes(v element.Element) { + o.indexes.Append(v) +} + +// RemoveIndexes removes the element at the given index from the indexes list. +func (o *Entity) RemoveIndexes(index int) { + o.indexes.Remove(index) +} + +// AccessRulesItems returns the value of the accessRules property. +func (o *Entity) AccessRulesItems() []element.Element { + return o.accessRules.Items() +} + +// AddAccessRules appends a child element to the accessRules list. +func (o *Entity) AddAccessRules(v element.Element) { + o.accessRules.Append(v) +} + +// RemoveAccessRules removes the element at the given index from the accessRules list. +func (o *Entity) RemoveAccessRules(index int) { + o.accessRules.Remove(index) +} + +// ImageQualifiedName returns the value of the image property. +func (o *Entity) ImageQualifiedName() string { + return o.image.QualifiedName() +} + +// SetImageQualifiedName sets the value of the image property. +func (o *Entity) SetImageQualifiedName(v string) { + o.image.SetQualifiedName(v) +} + +// ImageData returns the value of the imageData property. +func (o *Entity) ImageData() string { + return o.imageData.Get() +} + +// SetImageData sets the value of the imageData property. +func (o *Entity) SetImageData(v string) { + o.imageData.Set(v) +} + +// IsRemote returns the value of the isRemote property. +func (o *Entity) IsRemote() bool { + return o.isRemote.Get() +} + +// SetIsRemote sets the value of the isRemote property. +func (o *Entity) SetIsRemote(v bool) { + o.isRemote.Set(v) +} + +// RemoteSource returns the value of the remoteSource property. +func (o *Entity) RemoteSource() string { + return o.remoteSource.Get() +} + +// SetRemoteSource sets the value of the remoteSource property. +func (o *Entity) SetRemoteSource(v string) { + o.remoteSource.Set(v) +} + +// RemoteSourceDocumentQualifiedName returns the value of the remoteSourceDocument property. +func (o *Entity) RemoteSourceDocumentQualifiedName() string { + return o.remoteSourceDocument.QualifiedName() +} + +// SetRemoteSourceDocumentQualifiedName sets the value of the remoteSourceDocument property. +func (o *Entity) SetRemoteSourceDocumentQualifiedName(v string) { + o.remoteSourceDocument.SetQualifiedName(v) +} + +// Source returns the value of the source property. +func (o *Entity) Source() element.Element { + return o.source.Get() +} + +// SetSource sets the value of the source property. +func (o *Entity) SetSource(v element.Element) { + o.source.Set(v) +} + +// Capabilities returns the value of the capabilities property. +func (o *Entity) Capabilities() element.Element { + return o.capabilities.Get() +} + +// SetCapabilities sets the value of the capabilities property. +func (o *Entity) SetCapabilities(v element.Element) { + o.capabilities.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Entity) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Entity) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Entity) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.dataStorageGuid.Init(raw) + o.location.Init(raw) + o.documentation.Init(raw) + if child, err := codec.DecodeChild(raw, "Generalization"); err == nil { + o.generalization.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Attributes"); err == nil { + for _, child := range children { + o.attributes.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "ValidationRules"); err == nil { + for _, child := range children { + o.validationRules.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "EventHandlers"); err == nil { + for _, child := range children { + o.eventHandlers.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Indexes"); err == nil { + for _, child := range children { + o.indexes.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "AccessRules"); err == nil { + for _, child := range children { + o.accessRules.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Image"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.image.SetFromDecode(s) + } + } + o.imageData.Init(raw) + o.isRemote.Init(raw) + o.remoteSource.Init(raw) + if val, err := raw.LookupErr("RemoteSourceDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.remoteSourceDocument.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Source"); err == nil { + o.source.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Capabilities"); err == nil { + o.capabilities.SetFromDecode(child) + } + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// EntityCapabilities +// ──────────────────────────────────────────────────────── + +type EntityCapabilities struct { + element.Base + countable *property.Primitive[bool] +} + +// Countable returns the value of the countable property. +func (o *EntityCapabilities) Countable() bool { + return o.countable.Get() +} + +// SetCountable sets the value of the countable property. +func (o *EntityCapabilities) SetCountable(v bool) { + o.countable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityCapabilities) InitFromRaw(raw bson.Raw) { + o.countable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EntityKey +// ──────────────────────────────────────────────────────── + +type EntityKey struct { + element.Base + parts *property.PartList[element.Element] +} + +// PartsItems returns the value of the parts property. +func (o *EntityKey) PartsItems() []element.Element { + return o.parts.Items() +} + +// AddParts appends a child element to the parts list. +func (o *EntityKey) AddParts(v element.Element) { + o.parts.Append(v) +} + +// RemoveParts removes the element at the given index from the parts list. +func (o *EntityKey) RemoveParts(index int) { + o.parts.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityKey) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Parts"); err == nil { + for _, child := range children { + o.parts.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// EntityKeyPart +// ──────────────────────────────────────────────────────── + +type EntityKeyPart struct { + element.Base + name *property.Primitive[string] + propType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *EntityKeyPart) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *EntityKeyPart) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *EntityKeyPart) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *EntityKeyPart) SetType(v element.Element) { + o.propType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityKeyPart) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// EntityRefStep +// ──────────────────────────────────────────────────────── + +type EntityRefStep struct { + element.Base + association *property.ByNameRef[element.Element] + destinationEntity *property.ByNameRef[element.Element] +} + +// AssociationQualifiedName returns the value of the association property. +func (o *EntityRefStep) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *EntityRefStep) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// DestinationEntityQualifiedName returns the value of the destinationEntity property. +func (o *EntityRefStep) DestinationEntityQualifiedName() string { + return o.destinationEntity.QualifiedName() +} + +// SetDestinationEntityQualifiedName sets the value of the destinationEntity property. +func (o *EntityRefStep) SetDestinationEntityQualifiedName(v string) { + o.destinationEntity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityRefStep) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.association.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("DestinationEntity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.destinationEntity.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// EntitySource +// ──────────────────────────────────────────────────────── + +type EntitySource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntitySource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EnumerationAttributeType +// ──────────────────────────────────────────────────────── + +type EnumerationAttributeType struct { + element.Base + enumeration *property.ByNameRef[element.Element] +} + +// EnumerationQualifiedName returns the value of the enumeration property. +func (o *EnumerationAttributeType) EnumerationQualifiedName() string { + return o.enumeration.QualifiedName() +} + +// SetEnumerationQualifiedName sets the value of the enumeration property. +func (o *EnumerationAttributeType) SetEnumerationQualifiedName(v string) { + o.enumeration.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EnumerationAttributeType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Enumeration"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.enumeration.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// RuleInfo +// ──────────────────────────────────────────────────────── + +type RuleInfo struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RuleInfo) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EqualsToRuleInfo +// ──────────────────────────────────────────────────────── + +type EqualsToRuleInfo struct { + element.Base + useValue *property.Primitive[bool] + equalsToValue *property.Primitive[string] + equalsToAttribute *property.ByNameRef[element.Element] +} + +// UseValue returns the value of the useValue property. +func (o *EqualsToRuleInfo) UseValue() bool { + return o.useValue.Get() +} + +// SetUseValue sets the value of the useValue property. +func (o *EqualsToRuleInfo) SetUseValue(v bool) { + o.useValue.Set(v) +} + +// EqualsToValue returns the value of the equalsToValue property. +func (o *EqualsToRuleInfo) EqualsToValue() string { + return o.equalsToValue.Get() +} + +// SetEqualsToValue sets the value of the equalsToValue property. +func (o *EqualsToRuleInfo) SetEqualsToValue(v string) { + o.equalsToValue.Set(v) +} + +// EqualsToAttributeQualifiedName returns the value of the equalsToAttribute property. +func (o *EqualsToRuleInfo) EqualsToAttributeQualifiedName() string { + return o.equalsToAttribute.QualifiedName() +} + +// SetEqualsToAttributeQualifiedName sets the value of the equalsToAttribute property. +func (o *EqualsToRuleInfo) SetEqualsToAttributeQualifiedName(v string) { + o.equalsToAttribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EqualsToRuleInfo) InitFromRaw(raw bson.Raw) { + o.useValue.Init(raw) + o.equalsToValue.Init(raw) + if val, err := raw.LookupErr("EqualsToAttribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.equalsToAttribute.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// EventHandler +// ──────────────────────────────────────────────────────── + +type EventHandler struct { + element.Base + moment *property.Enum[string] + event *property.Enum[string] + microflow *property.ByNameRef[element.Element] + raiseErrorOnFalse *property.Primitive[bool] + passEventObject *property.Primitive[bool] +} + +// Moment returns the value of the moment property. +func (o *EventHandler) Moment() string { + return o.moment.Get() +} + +// SetMoment sets the value of the moment property. +func (o *EventHandler) SetMoment(v string) { + o.moment.Set(v) +} + +// Event returns the value of the event property. +func (o *EventHandler) Event() string { + return o.event.Get() +} + +// SetEvent sets the value of the event property. +func (o *EventHandler) SetEvent(v string) { + o.event.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *EventHandler) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *EventHandler) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// RaiseErrorOnFalse returns the value of the raiseErrorOnFalse property. +func (o *EventHandler) RaiseErrorOnFalse() bool { + return o.raiseErrorOnFalse.Get() +} + +// SetRaiseErrorOnFalse sets the value of the raiseErrorOnFalse property. +func (o *EventHandler) SetRaiseErrorOnFalse(v bool) { + o.raiseErrorOnFalse.Set(v) +} + +// PassEventObject returns the value of the passEventObject property. +func (o *EventHandler) PassEventObject() bool { + return o.passEventObject.Get() +} + +// SetPassEventObject sets the value of the passEventObject property. +func (o *EventHandler) SetPassEventObject(v bool) { + o.passEventObject.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EventHandler) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Moment"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.moment.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Event"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.event.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + o.raiseErrorOnFalse.Init(raw) + o.passEventObject.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// FloatAttributeType +// ──────────────────────────────────────────────────────── + +type FloatAttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FloatAttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// GeneralizationBase +// ──────────────────────────────────────────────────────── + +type GeneralizationBase struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GeneralizationBase) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Generalization +// ──────────────────────────────────────────────────────── + +type Generalization struct { + element.Base + generalization *property.ByNameRef[element.Element] +} + +// GeneralizationQualifiedName returns the value of the generalization property. +func (o *Generalization) GeneralizationQualifiedName() string { + return o.generalization.QualifiedName() +} + +// SetGeneralizationQualifiedName sets the value of the generalization property. +func (o *Generalization) SetGeneralizationQualifiedName(v string) { + o.generalization.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Generalization) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Generalization"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.generalization.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// HashedStringAttributeType +// ──────────────────────────────────────────────────────── + +type HashedStringAttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *HashedStringAttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Index +// ──────────────────────────────────────────────────────── + +type Index struct { + element.Base + dataStorageGuid *property.Primitive[string] + attributes *property.PartList[element.Element] + includeInOffline *property.Primitive[bool] +} + +// DataStorageGuid returns the value of the dataStorageGuid property. +func (o *Index) DataStorageGuid() string { + return o.dataStorageGuid.Get() +} + +// SetDataStorageGuid sets the value of the dataStorageGuid property. +func (o *Index) SetDataStorageGuid(v string) { + o.dataStorageGuid.Set(v) +} + +// AttributesItems returns the value of the attributes property. +func (o *Index) AttributesItems() []element.Element { + return o.attributes.Items() +} + +// AddAttributes appends a child element to the attributes list. +func (o *Index) AddAttributes(v element.Element) { + o.attributes.Append(v) +} + +// RemoveAttributes removes the element at the given index from the attributes list. +func (o *Index) RemoveAttributes(index int) { + o.attributes.Remove(index) +} + +// IncludeInOffline returns the value of the includeInOffline property. +func (o *Index) IncludeInOffline() bool { + return o.includeInOffline.Get() +} + +// SetIncludeInOffline sets the value of the includeInOffline property. +func (o *Index) SetIncludeInOffline(v bool) { + o.includeInOffline.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Index) InitFromRaw(raw bson.Raw) { + o.dataStorageGuid.Init(raw) + if children, err := codec.DecodeChildren(raw, "Attributes"); err == nil { + for _, child := range children { + o.attributes.AppendFromDecode(child) + } + } + o.includeInOffline.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// IndexedAttribute +// ──────────────────────────────────────────────────────── + +type IndexedAttribute struct { + element.Base + propType *property.Enum[string] + attribute *property.ByIdRef[element.Element] + ascending *property.Primitive[bool] +} + +// Type returns the value of the type property. +func (o *IndexedAttribute) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *IndexedAttribute) SetType(v string) { + o.propType.Set(v) +} + +// AttributeRefID returns the value of the attribute property. +func (o *IndexedAttribute) AttributeRefID() element.ID { + return o.attribute.RefID() +} + +// SetAttributeID sets the value of the attribute property. +func (o *IndexedAttribute) SetAttributeID(v element.ID) { + o.attribute.SetID(v) +} + +// Ascending returns the value of the ascending property. +func (o *IndexedAttribute) Ascending() bool { + return o.ascending.Get() +} + +// SetAscending sets the value of the ascending property. +func (o *IndexedAttribute) SetAscending(v bool) { + o.ascending.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IndexedAttribute) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("AttributePointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.attribute.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.ascending.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// IndirectEntityRef +// ──────────────────────────────────────────────────────── + +type IndirectEntityRef struct { + element.Base + steps *property.PartList[element.Element] +} + +// StepsItems returns the value of the steps property. +func (o *IndirectEntityRef) StepsItems() []element.Element { + return o.steps.Items() +} + +// AddSteps appends a child element to the steps list. +func (o *IndirectEntityRef) AddSteps(v element.Element) { + o.steps.Append(v) +} + +// RemoveSteps removes the element at the given index from the steps list. +func (o *IndirectEntityRef) RemoveSteps(index int) { + o.steps.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IndirectEntityRef) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Steps"); err == nil { + for _, child := range children { + o.steps.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// IntegerAttributeType +// ──────────────────────────────────────────────────────── + +type IntegerAttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IntegerAttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// LongAttributeType +// ──────────────────────────────────────────────────────── + +type LongAttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LongAttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// RemoteEntitySource +// ──────────────────────────────────────────────────────── + +type RemoteEntitySource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RemoteEntitySource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// MaterializedRemoteEntitySource +// ──────────────────────────────────────────────────────── + +type MaterializedRemoteEntitySource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MaterializedRemoteEntitySource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// MaxLengthRuleInfo +// ──────────────────────────────────────────────────────── + +type MaxLengthRuleInfo struct { + element.Base + maxLength *property.Primitive[int32] +} + +// MaxLength returns the value of the maxLength property. +func (o *MaxLengthRuleInfo) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *MaxLengthRuleInfo) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MaxLengthRuleInfo) InitFromRaw(raw bson.Raw) { + o.maxLength.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MemberAccess +// ──────────────────────────────────────────────────────── + +type MemberAccess struct { + element.Base + attribute *property.ByNameRef[element.Element] + association *property.ByNameRef[element.Element] + accessRights *property.Enum[string] +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *MemberAccess) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *MemberAccess) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *MemberAccess) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *MemberAccess) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// AccessRights returns the value of the accessRights property. +func (o *MemberAccess) AccessRights() string { + return o.accessRights.Get() +} + +// SetAccessRights sets the value of the accessRights property. +func (o *MemberAccess) SetAccessRights(v string) { + o.accessRights.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MemberAccess) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.association.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("AccessRights"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.accessRights.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// MultiLanguageAttributeType +// ──────────────────────────────────────────────────────── + +type MultiLanguageAttributeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MultiLanguageAttributeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// NoGeneralization +// ──────────────────────────────────────────────────────── + +type NoGeneralization struct { + element.Base + hasChangedDate *property.Primitive[bool] + hasCreatedDate *property.Primitive[bool] + hasOwner *property.Primitive[bool] + hasChangedBy *property.Primitive[bool] + persistable *property.Primitive[bool] +} + +// HasChangedDate returns the value of the hasChangedDate property. +func (o *NoGeneralization) HasChangedDate() bool { + return o.hasChangedDate.Get() +} + +// SetHasChangedDate sets the value of the hasChangedDate property. +func (o *NoGeneralization) SetHasChangedDate(v bool) { + o.hasChangedDate.Set(v) +} + +// HasCreatedDate returns the value of the hasCreatedDate property. +func (o *NoGeneralization) HasCreatedDate() bool { + return o.hasCreatedDate.Get() +} + +// SetHasCreatedDate sets the value of the hasCreatedDate property. +func (o *NoGeneralization) SetHasCreatedDate(v bool) { + o.hasCreatedDate.Set(v) +} + +// HasOwner returns the value of the hasOwner property. +func (o *NoGeneralization) HasOwner() bool { + return o.hasOwner.Get() +} + +// SetHasOwner sets the value of the hasOwner property. +func (o *NoGeneralization) SetHasOwner(v bool) { + o.hasOwner.Set(v) +} + +// HasChangedBy returns the value of the hasChangedBy property. +func (o *NoGeneralization) HasChangedBy() bool { + return o.hasChangedBy.Get() +} + +// SetHasChangedBy sets the value of the hasChangedBy property. +func (o *NoGeneralization) SetHasChangedBy(v bool) { + o.hasChangedBy.Set(v) +} + +// Persistable returns the value of the persistable property. +func (o *NoGeneralization) Persistable() bool { + return o.persistable.Get() +} + +// SetPersistable sets the value of the persistable property. +func (o *NoGeneralization) SetPersistable(v bool) { + o.persistable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NoGeneralization) InitFromRaw(raw bson.Raw) { + o.hasChangedDate.Init(raw) + o.hasCreatedDate.Init(raw) + o.hasOwner.Init(raw) + o.hasChangedBy.Init(raw) + o.persistable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OqlViewAssociationSource +// ──────────────────────────────────────────────────────── + +type OqlViewAssociationSource struct { + element.Base + reference *property.Primitive[string] +} + +// Reference returns the value of the reference property. +func (o *OqlViewAssociationSource) Reference() string { + return o.reference.Get() +} + +// SetReference sets the value of the reference property. +func (o *OqlViewAssociationSource) SetReference(v string) { + o.reference.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OqlViewAssociationSource) InitFromRaw(raw bson.Raw) { + o.reference.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ViewEntitySource +// ──────────────────────────────────────────────────────── + +type ViewEntitySource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ViewEntitySource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// OqlViewEntitySource +// ──────────────────────────────────────────────────────── + +type OqlViewEntitySource struct { + element.Base + sourceDocument *property.ByNameRef[element.Element] + oql *property.Primitive[string] +} + +// SourceDocumentQualifiedName returns the value of the sourceDocument property. +func (o *OqlViewEntitySource) SourceDocumentQualifiedName() string { + return o.sourceDocument.QualifiedName() +} + +// SetSourceDocumentQualifiedName sets the value of the sourceDocument property. +func (o *OqlViewEntitySource) SetSourceDocumentQualifiedName(v string) { + o.sourceDocument.SetQualifiedName(v) +} + +// Oql returns the value of the oql property. +func (o *OqlViewEntitySource) Oql() string { + return o.oql.Get() +} + +// SetOql sets the value of the oql property. +func (o *OqlViewEntitySource) SetOql(v string) { + o.oql.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OqlViewEntitySource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("SourceDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.sourceDocument.SetFromDecode(s) + } + } + o.oql.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OqlViewValue +// ──────────────────────────────────────────────────────── + +type OqlViewValue struct { + element.Base + reference *property.Primitive[string] +} + +// Reference returns the value of the reference property. +func (o *OqlViewValue) Reference() string { + return o.reference.Get() +} + +// SetReference sets the value of the reference property. +func (o *OqlViewValue) SetReference(v string) { + o.reference.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OqlViewValue) InitFromRaw(raw bson.Raw) { + o.reference.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// QueryBasedRemoteEntitySource +// ──────────────────────────────────────────────────────── + +type QueryBasedRemoteEntitySource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueryBasedRemoteEntitySource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// RangeRuleInfo +// ──────────────────────────────────────────────────────── + +type RangeRuleInfo struct { + element.Base + typeOfRange *property.Enum[string] + useMinValue *property.Primitive[bool] + useMaxValue *property.Primitive[bool] + minValue *property.Primitive[string] + maxValue *property.Primitive[string] + minAttribute *property.ByNameRef[element.Element] + maxAttribute *property.ByNameRef[element.Element] +} + +// TypeOfRange returns the value of the typeOfRange property. +func (o *RangeRuleInfo) TypeOfRange() string { + return o.typeOfRange.Get() +} + +// SetTypeOfRange sets the value of the typeOfRange property. +func (o *RangeRuleInfo) SetTypeOfRange(v string) { + o.typeOfRange.Set(v) +} + +// UseMinValue returns the value of the useMinValue property. +func (o *RangeRuleInfo) UseMinValue() bool { + return o.useMinValue.Get() +} + +// SetUseMinValue sets the value of the useMinValue property. +func (o *RangeRuleInfo) SetUseMinValue(v bool) { + o.useMinValue.Set(v) +} + +// UseMaxValue returns the value of the useMaxValue property. +func (o *RangeRuleInfo) UseMaxValue() bool { + return o.useMaxValue.Get() +} + +// SetUseMaxValue sets the value of the useMaxValue property. +func (o *RangeRuleInfo) SetUseMaxValue(v bool) { + o.useMaxValue.Set(v) +} + +// MinValue returns the value of the minValue property. +func (o *RangeRuleInfo) MinValue() string { + return o.minValue.Get() +} + +// SetMinValue sets the value of the minValue property. +func (o *RangeRuleInfo) SetMinValue(v string) { + o.minValue.Set(v) +} + +// MaxValue returns the value of the maxValue property. +func (o *RangeRuleInfo) MaxValue() string { + return o.maxValue.Get() +} + +// SetMaxValue sets the value of the maxValue property. +func (o *RangeRuleInfo) SetMaxValue(v string) { + o.maxValue.Set(v) +} + +// MinAttributeQualifiedName returns the value of the minAttribute property. +func (o *RangeRuleInfo) MinAttributeQualifiedName() string { + return o.minAttribute.QualifiedName() +} + +// SetMinAttributeQualifiedName sets the value of the minAttribute property. +func (o *RangeRuleInfo) SetMinAttributeQualifiedName(v string) { + o.minAttribute.SetQualifiedName(v) +} + +// MaxAttributeQualifiedName returns the value of the maxAttribute property. +func (o *RangeRuleInfo) MaxAttributeQualifiedName() string { + return o.maxAttribute.QualifiedName() +} + +// SetMaxAttributeQualifiedName sets the value of the maxAttribute property. +func (o *RangeRuleInfo) SetMaxAttributeQualifiedName(v string) { + o.maxAttribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RangeRuleInfo) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("TypeOfRange"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.typeOfRange.SetFromDecode(s) + } + } + o.useMinValue.Init(raw) + o.useMaxValue.Init(raw) + o.minValue.Init(raw) + o.maxValue.Init(raw) + if val, err := raw.LookupErr("MinAttribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.minAttribute.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("MaxAttribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.maxAttribute.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// RegExRuleInfo +// ──────────────────────────────────────────────────────── + +type RegExRuleInfo struct { + element.Base + regularExpression *property.ByNameRef[element.Element] +} + +// RegularExpressionQualifiedName returns the value of the regularExpression property. +func (o *RegExRuleInfo) RegularExpressionQualifiedName() string { + return o.regularExpression.QualifiedName() +} + +// SetRegularExpressionQualifiedName sets the value of the regularExpression property. +func (o *RegExRuleInfo) SetRegularExpressionQualifiedName(v string) { + o.regularExpression.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RegExRuleInfo) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("RegularExpression"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.regularExpression.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// RemoteAssociationSource +// ──────────────────────────────────────────────────────── + +type RemoteAssociationSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RemoteAssociationSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// RemoteEntitySourceDocument +// ──────────────────────────────────────────────────────── + +type RemoteEntitySourceDocument struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + description *property.Primitive[string] + catalogUrl *property.Primitive[string] + icon *property.Primitive[string] + metadata *property.Primitive[string] + metadataUrl *property.Primitive[string] + serviceName *property.Primitive[string] + version *property.Primitive[string] + endpointId *property.Primitive[string] + minimumMxVersion *property.Primitive[string] + recommendedMxVersion *property.Primitive[string] + applicationId *property.Primitive[string] + environmentType *property.Enum[string] + metadataHash *property.Primitive[string] + validated *property.Primitive[bool] + validatedEntities *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *RemoteEntitySourceDocument) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RemoteEntitySourceDocument) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *RemoteEntitySourceDocument) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *RemoteEntitySourceDocument) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *RemoteEntitySourceDocument) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *RemoteEntitySourceDocument) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *RemoteEntitySourceDocument) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *RemoteEntitySourceDocument) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Description returns the value of the description property. +func (o *RemoteEntitySourceDocument) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *RemoteEntitySourceDocument) SetDescription(v string) { + o.description.Set(v) +} + +// CatalogUrl returns the value of the catalogUrl property. +func (o *RemoteEntitySourceDocument) CatalogUrl() string { + return o.catalogUrl.Get() +} + +// SetCatalogUrl sets the value of the catalogUrl property. +func (o *RemoteEntitySourceDocument) SetCatalogUrl(v string) { + o.catalogUrl.Set(v) +} + +// Icon returns the value of the icon property. +func (o *RemoteEntitySourceDocument) Icon() string { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *RemoteEntitySourceDocument) SetIcon(v string) { + o.icon.Set(v) +} + +// Metadata returns the value of the metadata property. +func (o *RemoteEntitySourceDocument) Metadata() string { + return o.metadata.Get() +} + +// SetMetadata sets the value of the metadata property. +func (o *RemoteEntitySourceDocument) SetMetadata(v string) { + o.metadata.Set(v) +} + +// MetadataUrl returns the value of the metadataUrl property. +func (o *RemoteEntitySourceDocument) MetadataUrl() string { + return o.metadataUrl.Get() +} + +// SetMetadataUrl sets the value of the metadataUrl property. +func (o *RemoteEntitySourceDocument) SetMetadataUrl(v string) { + o.metadataUrl.Set(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *RemoteEntitySourceDocument) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *RemoteEntitySourceDocument) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// Version returns the value of the version property. +func (o *RemoteEntitySourceDocument) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *RemoteEntitySourceDocument) SetVersion(v string) { + o.version.Set(v) +} + +// EndpointId returns the value of the endpointId property. +func (o *RemoteEntitySourceDocument) EndpointId() string { + return o.endpointId.Get() +} + +// SetEndpointId sets the value of the endpointId property. +func (o *RemoteEntitySourceDocument) SetEndpointId(v string) { + o.endpointId.Set(v) +} + +// MinimumMxVersion returns the value of the minimumMxVersion property. +func (o *RemoteEntitySourceDocument) MinimumMxVersion() string { + return o.minimumMxVersion.Get() +} + +// SetMinimumMxVersion sets the value of the minimumMxVersion property. +func (o *RemoteEntitySourceDocument) SetMinimumMxVersion(v string) { + o.minimumMxVersion.Set(v) +} + +// RecommendedMxVersion returns the value of the recommendedMxVersion property. +func (o *RemoteEntitySourceDocument) RecommendedMxVersion() string { + return o.recommendedMxVersion.Get() +} + +// SetRecommendedMxVersion sets the value of the recommendedMxVersion property. +func (o *RemoteEntitySourceDocument) SetRecommendedMxVersion(v string) { + o.recommendedMxVersion.Set(v) +} + +// ApplicationId returns the value of the applicationId property. +func (o *RemoteEntitySourceDocument) ApplicationId() string { + return o.applicationId.Get() +} + +// SetApplicationId sets the value of the applicationId property. +func (o *RemoteEntitySourceDocument) SetApplicationId(v string) { + o.applicationId.Set(v) +} + +// EnvironmentType returns the value of the environmentType property. +func (o *RemoteEntitySourceDocument) EnvironmentType() string { + return o.environmentType.Get() +} + +// SetEnvironmentType sets the value of the environmentType property. +func (o *RemoteEntitySourceDocument) SetEnvironmentType(v string) { + o.environmentType.Set(v) +} + +// MetadataHash returns the value of the metadataHash property. +func (o *RemoteEntitySourceDocument) MetadataHash() string { + return o.metadataHash.Get() +} + +// SetMetadataHash sets the value of the metadataHash property. +func (o *RemoteEntitySourceDocument) SetMetadataHash(v string) { + o.metadataHash.Set(v) +} + +// Validated returns the value of the validated property. +func (o *RemoteEntitySourceDocument) Validated() bool { + return o.validated.Get() +} + +// SetValidated sets the value of the validated property. +func (o *RemoteEntitySourceDocument) SetValidated(v bool) { + o.validated.Set(v) +} + +// ValidatedEntities returns the value of the validatedEntities property. +func (o *RemoteEntitySourceDocument) ValidatedEntities() string { + return o.validatedEntities.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RemoteEntitySourceDocument) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.description.Init(raw) + o.catalogUrl.Init(raw) + o.icon.Init(raw) + o.metadata.Init(raw) + o.metadataUrl.Init(raw) + o.serviceName.Init(raw) + o.version.Init(raw) + o.endpointId.Init(raw) + o.minimumMxVersion.Init(raw) + o.recommendedMxVersion.Init(raw) + o.applicationId.Init(raw) + if val, err := raw.LookupErr("EnvironmentType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.environmentType.SetFromDecode(s) + } + } + o.metadataHash.Init(raw) + o.validated.Init(raw) + o.validatedEntities.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RequiredRuleInfo +// ──────────────────────────────────────────────────────── + +type RequiredRuleInfo struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RequiredRuleInfo) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// StoredValue +// ──────────────────────────────────────────────────────── + +type StoredValue struct { + element.Base + defaultValue *property.Primitive[string] +} + +// DefaultValue returns the value of the defaultValue property. +func (o *StoredValue) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *StoredValue) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StoredValue) InitFromRaw(raw bson.Raw) { + o.defaultValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// StringAttributeType +// ──────────────────────────────────────────────────────── + +type StringAttributeType struct { + element.Base + length *property.Primitive[int32] +} + +// Length returns the value of the length property. +func (o *StringAttributeType) Length() int32 { + return o.length.Get() +} + +// SetLength sets the value of the length property. +func (o *StringAttributeType) SetLength(v int32) { + o.length.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringAttributeType) InitFromRaw(raw bson.Raw) { + o.length.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// UniqueRuleInfo +// ──────────────────────────────────────────────────────── + +type UniqueRuleInfo struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UniqueRuleInfo) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ValidationRule +// ──────────────────────────────────────────────────────── + +type ValidationRule struct { + element.Base + attribute *property.ByNameRef[element.Element] + errorMessage *property.Part[element.Element] + ruleInfo *property.Part[element.Element] +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ValidationRule) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ValidationRule) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *ValidationRule) ErrorMessage() element.Element { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *ValidationRule) SetErrorMessage(v element.Element) { + o.errorMessage.Set(v) +} + +// RuleInfo returns the value of the ruleInfo property. +func (o *ValidationRule) RuleInfo() element.Element { + return o.ruleInfo.Get() +} + +// SetRuleInfo sets the value of the ruleInfo property. +func (o *ValidationRule) SetRuleInfo(v element.Element) { + o.ruleInfo.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ValidationRule) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "ErrorMessage"); err == nil { + o.errorMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "RuleInfo"); err == nil { + o.ruleInfo.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ViewEntitySourceDocument +// ──────────────────────────────────────────────────────── + +type ViewEntitySourceDocument struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + oql *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *ViewEntitySourceDocument) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ViewEntitySourceDocument) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ViewEntitySourceDocument) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ViewEntitySourceDocument) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ViewEntitySourceDocument) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ViewEntitySourceDocument) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ViewEntitySourceDocument) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ViewEntitySourceDocument) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Oql returns the value of the oql property. +func (o *ViewEntitySourceDocument) Oql() string { + return o.oql.Get() +} + +// SetOql sets the value of the oql property. +func (o *ViewEntitySourceDocument) SetOql(v string) { + o.oql.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ViewEntitySourceDocument) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.oql.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initAccessRule creates a AccessRule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAccessRule() *AccessRule { + o := &AccessRule{} + o.SetTypeName("DomainModels$AccessRule") + o.memberAccesses = property.NewPartList[element.Element]("MemberAccesses") + o.memberAccesses.Bind(&o.Base, 0) + o.moduleRoles = property.NewByNameRefList[element.Element]("ModuleRoles", "Security$ModuleRole") + o.moduleRoles.Bind(&o.Base, 1) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 2) + o.allowCreate = property.NewPrimitive[bool]("AllowCreate", property.DecodeBool) + o.allowCreate.Bind(&o.Base, 3) + o.allowDelete = property.NewPrimitive[bool]("AllowDelete", property.DecodeBool) + o.allowDelete.Bind(&o.Base, 4) + o.defaultMemberAccessRights = property.NewEnum[string]("DefaultMemberAccessRights") + o.defaultMemberAccessRights.Bind(&o.Base, 5) + o.xPathConstraintCaption = property.NewPrimitive[string]("XPathConstraintCaption", property.DecodeString) + o.xPathConstraintCaption.Bind(&o.Base, 6) + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.memberAccesses, o.moduleRoles, o.documentation, o.allowCreate, o.allowDelete, o.defaultMemberAccessRights, o.xPathConstraintCaption, o.xPathConstraint}) + return o +} + +// NewAccessRule creates a new AccessRule for user code. Marked dirty (bit 63 = new element). +func NewAccessRule() *AccessRule { + o := initAccessRule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAnnotation creates a Annotation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAnnotation() *Annotation { + o := &Annotation{} + o.SetTypeName("DomainModels$Annotation") + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 0) + o.location = property.NewPrimitive[string]("Location", property.DecodeString) + o.location.Bind(&o.Base, 1) + o.width = property.NewPrimitive[int32]("Width", property.DecodeInt32) + o.width.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.caption, o.location, o.width, o.exportLevel}) + return o +} + +// NewAnnotation creates a new Annotation for user code. Marked dirty (bit 63 = new element). +func NewAnnotation() *Annotation { + o := initAnnotation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAssociation creates a Association with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAssociation() *Association { + o := &Association{} + o.SetTypeName("DomainModels$Association") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.dataStorageGuid = property.NewPrimitive[string]("DataStorageGuid", property.DecodeString) + o.dataStorageGuid.Bind(&o.Base, 1) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 2) + o.owner = property.NewEnum[string]("Owner") + o.owner.Bind(&o.Base, 3) + o.storageFormat = property.NewEnum[string]("StorageFormat") + o.storageFormat.Bind(&o.Base, 4) + o.deleteBehavior = property.NewPart[element.Element]("DeleteBehavior") + o.deleteBehavior.Bind(&o.Base, 5) + o.parent = property.NewByIdRef[element.Element]("ParentPointer") + o.parent.Bind(&o.Base, 6) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 7) + o.remoteSourceDocument = property.NewByNameRef[element.Element]("RemoteSourceDocument", "DomainModels$RemoteEntitySourceDocument") + o.remoteSourceDocument.Bind(&o.Base, 8) + o.source = property.NewPart[element.Element]("Source") + o.source.Bind(&o.Base, 9) + o.capabilities = property.NewPart[element.Element]("Capabilities") + o.capabilities.Bind(&o.Base, 10) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 11) + o.child = property.NewByIdRef[element.Element]("ChildPointer") + o.child.Bind(&o.Base, 12) + o.parentConnection = property.NewPrimitive[string]("ParentConnection", property.DecodeString) + o.parentConnection.Bind(&o.Base, 13) + o.childConnection = property.NewPrimitive[string]("ChildConnection", property.DecodeString) + o.childConnection.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.name, o.dataStorageGuid, o.propType, o.owner, o.storageFormat, o.deleteBehavior, o.parent, o.documentation, o.remoteSourceDocument, o.source, o.capabilities, o.exportLevel, o.child, o.parentConnection, o.childConnection}) + return o +} + +// NewAssociation creates a new Association for user code. Marked dirty (bit 63 = new element). +func NewAssociation() *Association { + o := initAssociation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAssociationCapabilities creates a AssociationCapabilities with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAssociationCapabilities() *AssociationCapabilities { + o := &AssociationCapabilities{} + o.SetTypeName("DomainModels$AssociationCapabilities") + o.navigability = property.NewEnum[string]("Navigability") + o.navigability.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.navigability}) + return o +} + +// NewAssociationCapabilities creates a new AssociationCapabilities for user code. Marked dirty (bit 63 = new element). +func NewAssociationCapabilities() *AssociationCapabilities { + o := initAssociationCapabilities() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAssociationDeleteBehavior creates a AssociationDeleteBehavior with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAssociationDeleteBehavior() *AssociationDeleteBehavior { + o := &AssociationDeleteBehavior{} + o.SetTypeName("DomainModels$DeleteBehavior") + o.parentDeleteBehavior = property.NewEnum[string]("ParentDeleteBehavior") + o.parentDeleteBehavior.Bind(&o.Base, 0) + o.childDeleteBehavior = property.NewEnum[string]("ChildDeleteBehavior") + o.childDeleteBehavior.Bind(&o.Base, 1) + o.parentErrorMessage = property.NewPart[element.Element]("ParentErrorMessage") + o.parentErrorMessage.Bind(&o.Base, 2) + o.childErrorMessage = property.NewPart[element.Element]("ChildErrorMessage") + o.childErrorMessage.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.parentDeleteBehavior, o.childDeleteBehavior, o.parentErrorMessage, o.childErrorMessage}) + return o +} + +// NewAssociationDeleteBehavior creates a new AssociationDeleteBehavior for user code. Marked dirty (bit 63 = new element). +func NewAssociationDeleteBehavior() *AssociationDeleteBehavior { + o := initAssociationDeleteBehavior() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAssociationRef creates a AssociationRef with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAssociationRef() *AssociationRef { + o := &AssociationRef{} + o.SetTypeName("DomainModels$AssociationRef") + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 0) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.entityRef, o.association}) + return o +} + +// NewAssociationRef creates a new AssociationRef for user code. Marked dirty (bit 63 = new element). +func NewAssociationRef() *AssociationRef { + o := initAssociationRef() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAttribute creates a Attribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAttribute() *Attribute { + o := &Attribute{} + o.SetTypeName("DomainModels$Attribute") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.dataStorageGuid = property.NewPrimitive[string]("DataStorageGuid", property.DecodeString) + o.dataStorageGuid.Bind(&o.Base, 1) + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 2) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 3) + o.value = property.NewPart[element.Element]("Value") + o.value.Bind(&o.Base, 4) + o.capabilities = property.NewPart[element.Element]("Capabilities") + o.capabilities.Bind(&o.Base, 5) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.dataStorageGuid, o.propType, o.documentation, o.value, o.capabilities, o.exportLevel}) + return o +} + +// NewAttribute creates a new Attribute for user code. Marked dirty (bit 63 = new element). +func NewAttribute() *Attribute { + o := initAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAttributeCapabilities creates a AttributeCapabilities with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAttributeCapabilities() *AttributeCapabilities { + o := &AttributeCapabilities{} + o.SetTypeName("DomainModels$AttributeCapabilities") + o.filterable = property.NewPrimitive[bool]("Filterable", property.DecodeBool) + o.filterable.Bind(&o.Base, 0) + o.sortable = property.NewPrimitive[bool]("Sortable", property.DecodeBool) + o.sortable.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.filterable, o.sortable}) + return o +} + +// NewAttributeCapabilities creates a new AttributeCapabilities for user code. Marked dirty (bit 63 = new element). +func NewAttributeCapabilities() *AttributeCapabilities { + o := initAttributeCapabilities() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAttributeRef creates a AttributeRef with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAttributeRef() *AttributeRef { + o := &AttributeRef{} + o.SetTypeName("DomainModels$AttributeRef") + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 0) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.entityRef, o.attribute}) + return o +} + +// NewAttributeRef creates a new AttributeRef for user code. Marked dirty (bit 63 = new element). +func NewAttributeRef() *AttributeRef { + o := initAttributeRef() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAutoNumberAttributeType creates a AutoNumberAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAutoNumberAttributeType() *AutoNumberAttributeType { + o := &AutoNumberAttributeType{} + o.SetTypeName("DomainModels$AutoNumberAttributeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewAutoNumberAttributeType creates a new AutoNumberAttributeType for user code. Marked dirty (bit 63 = new element). +func NewAutoNumberAttributeType() *AutoNumberAttributeType { + o := initAutoNumberAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBinaryAttributeType creates a BinaryAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBinaryAttributeType() *BinaryAttributeType { + o := &BinaryAttributeType{} + o.SetTypeName("DomainModels$BinaryAttributeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewBinaryAttributeType creates a new BinaryAttributeType for user code. Marked dirty (bit 63 = new element). +func NewBinaryAttributeType() *BinaryAttributeType { + o := initBinaryAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBooleanAttributeType creates a BooleanAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBooleanAttributeType() *BooleanAttributeType { + o := &BooleanAttributeType{} + o.SetTypeName("DomainModels$BooleanAttributeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewBooleanAttributeType creates a new BooleanAttributeType for user code. Marked dirty (bit 63 = new element). +func NewBooleanAttributeType() *BooleanAttributeType { + o := initBooleanAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCalculatedValue creates a CalculatedValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCalculatedValue() *CalculatedValue { + o := &CalculatedValue{} + o.SetTypeName("DomainModels$CalculatedValue") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.passEntity = property.NewPrimitive[bool]("PassEntity", property.DecodeBool) + o.passEntity.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.microflow, o.passEntity}) + return o +} + +// NewCalculatedValue creates a new CalculatedValue for user code. Marked dirty (bit 63 = new element). +func NewCalculatedValue() *CalculatedValue { + o := initCalculatedValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCrossAssociation creates a CrossAssociation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCrossAssociation() *CrossAssociation { + o := &CrossAssociation{} + o.SetTypeName("DomainModels$CrossAssociation") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.dataStorageGuid = property.NewPrimitive[string]("DataStorageGuid", property.DecodeString) + o.dataStorageGuid.Bind(&o.Base, 1) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 2) + o.owner = property.NewEnum[string]("Owner") + o.owner.Bind(&o.Base, 3) + o.storageFormat = property.NewEnum[string]("StorageFormat") + o.storageFormat.Bind(&o.Base, 4) + o.deleteBehavior = property.NewPart[element.Element]("DeleteBehavior") + o.deleteBehavior.Bind(&o.Base, 5) + o.parent = property.NewByIdRef[element.Element]("ParentPointer") + o.parent.Bind(&o.Base, 6) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 7) + o.remoteSourceDocument = property.NewByNameRef[element.Element]("RemoteSourceDocument", "DomainModels$RemoteEntitySourceDocument") + o.remoteSourceDocument.Bind(&o.Base, 8) + o.source = property.NewPart[element.Element]("Source") + o.source.Bind(&o.Base, 9) + o.capabilities = property.NewPart[element.Element]("Capabilities") + o.capabilities.Bind(&o.Base, 10) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 11) + o.child = property.NewByNameRef[element.Element]("Child", "DomainModels$Entity") + o.child.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.dataStorageGuid, o.propType, o.owner, o.storageFormat, o.deleteBehavior, o.parent, o.documentation, o.remoteSourceDocument, o.source, o.capabilities, o.exportLevel, o.child}) + return o +} + +// NewCrossAssociation creates a new CrossAssociation for user code. Marked dirty (bit 63 = new element). +func NewCrossAssociation() *CrossAssociation { + o := initCrossAssociation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCurrencyAttributeType creates a CurrencyAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCurrencyAttributeType() *CurrencyAttributeType { + o := &CurrencyAttributeType{} + o.SetTypeName("DomainModels$CurrencyAttributeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewCurrencyAttributeType creates a new CurrencyAttributeType for user code. Marked dirty (bit 63 = new element). +func NewCurrencyAttributeType() *CurrencyAttributeType { + o := initCurrencyAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDateTimeAttributeType creates a DateTimeAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDateTimeAttributeType() *DateTimeAttributeType { + o := &DateTimeAttributeType{} + o.SetTypeName("DomainModels$DateTimeAttributeType") + o.localizeDate = property.NewPrimitive[bool]("LocalizeDate", property.DecodeBool) + o.localizeDate.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.localizeDate}) + return o +} + +// NewDateTimeAttributeType creates a new DateTimeAttributeType for user code. Marked dirty (bit 63 = new element). +func NewDateTimeAttributeType() *DateTimeAttributeType { + o := initDateTimeAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDecimalAttributeType creates a DecimalAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDecimalAttributeType() *DecimalAttributeType { + o := &DecimalAttributeType{} + o.SetTypeName("DomainModels$DecimalAttributeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewDecimalAttributeType creates a new DecimalAttributeType for user code. Marked dirty (bit 63 = new element). +func NewDecimalAttributeType() *DecimalAttributeType { + o := initDecimalAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDirectEntityRef creates a DirectEntityRef with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDirectEntityRef() *DirectEntityRef { + o := &DirectEntityRef{} + o.SetTypeName("DomainModels$DirectEntityRef") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.entity}) + return o +} + +// NewDirectEntityRef creates a new DirectEntityRef for user code. Marked dirty (bit 63 = new element). +func NewDirectEntityRef() *DirectEntityRef { + o := initDirectEntityRef() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDomainModel creates a DomainModel with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDomainModel() *DomainModel { + o := &DomainModel{} + o.SetTypeName("DomainModels$DomainModel") + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 0) + o.entities = property.NewPartList[element.Element]("Entities") + o.entities.Bind(&o.Base, 1) + o.annotations = property.NewPartList[element.Element]("Annotations") + o.annotations.Bind(&o.Base, 2) + o.associations = property.NewPartList[element.Element]("Associations") + o.associations.Bind(&o.Base, 3) + o.crossAssociations = property.NewPartList[element.Element]("CrossAssociations") + o.crossAssociations.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.documentation, o.entities, o.annotations, o.associations, o.crossAssociations}) + return o +} + +// NewDomainModel creates a new DomainModel for user code. Marked dirty (bit 63 = new element). +func NewDomainModel() *DomainModel { + o := initDomainModel() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntity creates a Entity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntity() *Entity { + o := &Entity{} + o.SetTypeName("DomainModels$EntityImpl") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.dataStorageGuid = property.NewPrimitive[string]("DataStorageGuid", property.DecodeString) + o.dataStorageGuid.Bind(&o.Base, 1) + o.location = property.NewPrimitive[string]("Location", property.DecodeString) + o.location.Bind(&o.Base, 2) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 3) + o.generalization = property.NewPart[element.Element]("Generalization") + o.generalization.Bind(&o.Base, 4) + o.attributes = property.NewPartList[element.Element]("Attributes") + o.attributes.Bind(&o.Base, 5) + o.validationRules = property.NewPartList[element.Element]("ValidationRules") + o.validationRules.Bind(&o.Base, 6) + o.eventHandlers = property.NewPartList[element.Element]("EventHandlers") + o.eventHandlers.Bind(&o.Base, 7) + o.indexes = property.NewPartList[element.Element]("Indexes") + o.indexes.Bind(&o.Base, 8) + o.accessRules = property.NewPartList[element.Element]("AccessRules") + o.accessRules.Bind(&o.Base, 9) + o.image = property.NewByNameRef[element.Element]("Image", "Images$Image") + o.image.Bind(&o.Base, 10) + o.imageData = property.NewPrimitive[string]("ImageData", property.DecodeString) + o.imageData.Bind(&o.Base, 11) + o.isRemote = property.NewPrimitive[bool]("IsRemote", property.DecodeBool) + o.isRemote.Bind(&o.Base, 12) + o.remoteSource = property.NewPrimitive[string]("RemoteSource", property.DecodeString) + o.remoteSource.Bind(&o.Base, 13) + o.remoteSourceDocument = property.NewByNameRef[element.Element]("RemoteSourceDocument", "DomainModels$RemoteEntitySourceDocument") + o.remoteSourceDocument.Bind(&o.Base, 14) + o.source = property.NewPart[element.Element]("Source") + o.source.Bind(&o.Base, 15) + o.capabilities = property.NewPart[element.Element]("Capabilities") + o.capabilities.Bind(&o.Base, 16) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 17) + o.SetProperties([]element.Property{o.name, o.dataStorageGuid, o.location, o.documentation, o.generalization, o.attributes, o.validationRules, o.eventHandlers, o.indexes, o.accessRules, o.image, o.imageData, o.isRemote, o.remoteSource, o.remoteSourceDocument, o.source, o.capabilities, o.exportLevel}) + return o +} + +// NewEntity creates a new Entity for user code. Marked dirty (bit 63 = new element). +func NewEntity() *Entity { + o := initEntity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityCapabilities creates a EntityCapabilities with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityCapabilities() *EntityCapabilities { + o := &EntityCapabilities{} + o.SetTypeName("DomainModels$EntityCapabilities") + o.countable = property.NewPrimitive[bool]("Countable", property.DecodeBool) + o.countable.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.countable}) + return o +} + +// NewEntityCapabilities creates a new EntityCapabilities for user code. Marked dirty (bit 63 = new element). +func NewEntityCapabilities() *EntityCapabilities { + o := initEntityCapabilities() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityKey creates a EntityKey with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityKey() *EntityKey { + o := &EntityKey{} + o.SetTypeName("DomainModels$EntityKey") + o.parts = property.NewPartList[element.Element]("Parts") + o.parts.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.parts}) + return o +} + +// NewEntityKey creates a new EntityKey for user code. Marked dirty (bit 63 = new element). +func NewEntityKey() *EntityKey { + o := initEntityKey() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityKeyPart creates a EntityKeyPart with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityKeyPart() *EntityKeyPart { + o := &EntityKeyPart{} + o.SetTypeName("DomainModels$EntityKeyPart") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.propType}) + return o +} + +// NewEntityKeyPart creates a new EntityKeyPart for user code. Marked dirty (bit 63 = new element). +func NewEntityKeyPart() *EntityKeyPart { + o := initEntityKeyPart() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityRefStep creates a EntityRefStep with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityRefStep() *EntityRefStep { + o := &EntityRefStep{} + o.SetTypeName("DomainModels$EntityRefStep") + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 0) + o.destinationEntity = property.NewByNameRef[element.Element]("DestinationEntity", "DomainModels$Entity") + o.destinationEntity.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.association, o.destinationEntity}) + return o +} + +// NewEntityRefStep creates a new EntityRefStep for user code. Marked dirty (bit 63 = new element). +func NewEntityRefStep() *EntityRefStep { + o := initEntityRefStep() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEnumerationAttributeType creates a EnumerationAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEnumerationAttributeType() *EnumerationAttributeType { + o := &EnumerationAttributeType{} + o.SetTypeName("DomainModels$EnumerationAttributeType") + o.enumeration = property.NewByNameRef[element.Element]("Enumeration", "Enumerations$Enumeration") + o.enumeration.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.enumeration}) + return o +} + +// NewEnumerationAttributeType creates a new EnumerationAttributeType for user code. Marked dirty (bit 63 = new element). +func NewEnumerationAttributeType() *EnumerationAttributeType { + o := initEnumerationAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEqualsToRuleInfo creates a EqualsToRuleInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEqualsToRuleInfo() *EqualsToRuleInfo { + o := &EqualsToRuleInfo{} + o.SetTypeName("DomainModels$EqualsToRuleInfo") + o.useValue = property.NewPrimitive[bool]("UseValue", property.DecodeBool) + o.useValue.Bind(&o.Base, 0) + o.equalsToValue = property.NewPrimitive[string]("EqualsToValue", property.DecodeString) + o.equalsToValue.Bind(&o.Base, 1) + o.equalsToAttribute = property.NewByNameRef[element.Element]("EqualsToAttribute", "DomainModels$Attribute") + o.equalsToAttribute.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.useValue, o.equalsToValue, o.equalsToAttribute}) + return o +} + +// NewEqualsToRuleInfo creates a new EqualsToRuleInfo for user code. Marked dirty (bit 63 = new element). +func NewEqualsToRuleInfo() *EqualsToRuleInfo { + o := initEqualsToRuleInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEventHandler creates a EventHandler with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEventHandler() *EventHandler { + o := &EventHandler{} + o.SetTypeName("DomainModels$EntityEvent") + o.moment = property.NewEnum[string]("Moment") + o.moment.Bind(&o.Base, 0) + o.event = property.NewEnum[string]("Event") + o.event.Bind(&o.Base, 1) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 2) + o.raiseErrorOnFalse = property.NewPrimitive[bool]("RaiseErrorOnFalse", property.DecodeBool) + o.raiseErrorOnFalse.Bind(&o.Base, 3) + o.passEventObject = property.NewPrimitive[bool]("PassEventObject", property.DecodeBool) + o.passEventObject.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.moment, o.event, o.microflow, o.raiseErrorOnFalse, o.passEventObject}) + return o +} + +// NewEventHandler creates a new EventHandler for user code. Marked dirty (bit 63 = new element). +func NewEventHandler() *EventHandler { + o := initEventHandler() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFloatAttributeType creates a FloatAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFloatAttributeType() *FloatAttributeType { + o := &FloatAttributeType{} + o.SetTypeName("DomainModels$FloatAttributeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewFloatAttributeType creates a new FloatAttributeType for user code. Marked dirty (bit 63 = new element). +func NewFloatAttributeType() *FloatAttributeType { + o := initFloatAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGeneralization creates a Generalization with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGeneralization() *Generalization { + o := &Generalization{} + o.SetTypeName("DomainModels$Generalization") + o.generalization = property.NewByNameRef[element.Element]("Generalization", "DomainModels$Entity") + o.generalization.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.generalization}) + return o +} + +// NewGeneralization creates a new Generalization for user code. Marked dirty (bit 63 = new element). +func NewGeneralization() *Generalization { + o := initGeneralization() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initHashedStringAttributeType creates a HashedStringAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initHashedStringAttributeType() *HashedStringAttributeType { + o := &HashedStringAttributeType{} + o.SetTypeName("DomainModels$HashedStringAttributeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewHashedStringAttributeType creates a new HashedStringAttributeType for user code. Marked dirty (bit 63 = new element). +func NewHashedStringAttributeType() *HashedStringAttributeType { + o := initHashedStringAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIndex creates a Index with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIndex() *Index { + o := &Index{} + o.SetTypeName("DomainModels$EntityIndex") + o.dataStorageGuid = property.NewPrimitive[string]("DataStorageGuid", property.DecodeString) + o.dataStorageGuid.Bind(&o.Base, 0) + o.attributes = property.NewPartList[element.Element]("Attributes") + o.attributes.Bind(&o.Base, 1) + o.includeInOffline = property.NewPrimitive[bool]("IncludeInOffline", property.DecodeBool) + o.includeInOffline.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.dataStorageGuid, o.attributes, o.includeInOffline}) + return o +} + +// NewIndex creates a new Index for user code. Marked dirty (bit 63 = new element). +func NewIndex() *Index { + o := initIndex() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIndexedAttribute creates a IndexedAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIndexedAttribute() *IndexedAttribute { + o := &IndexedAttribute{} + o.SetTypeName("DomainModels$IndexedAttribute") + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 0) + o.attribute = property.NewByIdRef[element.Element]("AttributePointer") + o.attribute.Bind(&o.Base, 1) + o.ascending = property.NewPrimitive[bool]("Ascending", property.DecodeBool) + o.ascending.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.propType, o.attribute, o.ascending}) + return o +} + +// NewIndexedAttribute creates a new IndexedAttribute for user code. Marked dirty (bit 63 = new element). +func NewIndexedAttribute() *IndexedAttribute { + o := initIndexedAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIndirectEntityRef creates a IndirectEntityRef with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIndirectEntityRef() *IndirectEntityRef { + o := &IndirectEntityRef{} + o.SetTypeName("DomainModels$IndirectEntityRef") + o.steps = property.NewPartList[element.Element]("Steps") + o.steps.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.steps}) + return o +} + +// NewIndirectEntityRef creates a new IndirectEntityRef for user code. Marked dirty (bit 63 = new element). +func NewIndirectEntityRef() *IndirectEntityRef { + o := initIndirectEntityRef() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIntegerAttributeType creates a IntegerAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIntegerAttributeType() *IntegerAttributeType { + o := &IntegerAttributeType{} + o.SetTypeName("DomainModels$IntegerAttributeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewIntegerAttributeType creates a new IntegerAttributeType for user code. Marked dirty (bit 63 = new element). +func NewIntegerAttributeType() *IntegerAttributeType { + o := initIntegerAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLongAttributeType creates a LongAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLongAttributeType() *LongAttributeType { + o := &LongAttributeType{} + o.SetTypeName("DomainModels$LongAttributeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewLongAttributeType creates a new LongAttributeType for user code. Marked dirty (bit 63 = new element). +func NewLongAttributeType() *LongAttributeType { + o := initLongAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMaxLengthRuleInfo creates a MaxLengthRuleInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMaxLengthRuleInfo() *MaxLengthRuleInfo { + o := &MaxLengthRuleInfo{} + o.SetTypeName("DomainModels$MaxLengthRuleInfo") + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.maxLength}) + return o +} + +// NewMaxLengthRuleInfo creates a new MaxLengthRuleInfo for user code. Marked dirty (bit 63 = new element). +func NewMaxLengthRuleInfo() *MaxLengthRuleInfo { + o := initMaxLengthRuleInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMemberAccess creates a MemberAccess with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMemberAccess() *MemberAccess { + o := &MemberAccess{} + o.SetTypeName("DomainModels$MemberAccess") + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 0) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 1) + o.accessRights = property.NewEnum[string]("AccessRights") + o.accessRights.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.attribute, o.association, o.accessRights}) + return o +} + +// NewMemberAccess creates a new MemberAccess for user code. Marked dirty (bit 63 = new element). +func NewMemberAccess() *MemberAccess { + o := initMemberAccess() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMultiLanguageAttributeType creates a MultiLanguageAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMultiLanguageAttributeType() *MultiLanguageAttributeType { + o := &MultiLanguageAttributeType{} + o.SetTypeName("DomainModels$MultiLanguageAttributeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewMultiLanguageAttributeType creates a new MultiLanguageAttributeType for user code. Marked dirty (bit 63 = new element). +func NewMultiLanguageAttributeType() *MultiLanguageAttributeType { + o := initMultiLanguageAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNoGeneralization creates a NoGeneralization with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNoGeneralization() *NoGeneralization { + o := &NoGeneralization{} + o.SetTypeName("DomainModels$NoGeneralization") + o.hasChangedDate = property.NewPrimitive[bool]("HasChangedDate", property.DecodeBool) + o.hasChangedDate.Bind(&o.Base, 0) + o.hasCreatedDate = property.NewPrimitive[bool]("HasCreatedDate", property.DecodeBool) + o.hasCreatedDate.Bind(&o.Base, 1) + o.hasOwner = property.NewPrimitive[bool]("HasOwner", property.DecodeBool) + o.hasOwner.Bind(&o.Base, 2) + o.hasChangedBy = property.NewPrimitive[bool]("HasChangedBy", property.DecodeBool) + o.hasChangedBy.Bind(&o.Base, 3) + o.persistable = property.NewPrimitive[bool]("Persistable", property.DecodeBool) + o.persistable.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.hasChangedDate, o.hasCreatedDate, o.hasOwner, o.hasChangedBy, o.persistable}) + return o +} + +// NewNoGeneralization creates a new NoGeneralization for user code. Marked dirty (bit 63 = new element). +func NewNoGeneralization() *NoGeneralization { + o := initNoGeneralization() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOqlViewAssociationSource creates a OqlViewAssociationSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOqlViewAssociationSource() *OqlViewAssociationSource { + o := &OqlViewAssociationSource{} + o.SetTypeName("DomainModels$OqlViewAssociationSource") + o.reference = property.NewPrimitive[string]("Reference", property.DecodeString) + o.reference.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.reference}) + return o +} + +// NewOqlViewAssociationSource creates a new OqlViewAssociationSource for user code. Marked dirty (bit 63 = new element). +func NewOqlViewAssociationSource() *OqlViewAssociationSource { + o := initOqlViewAssociationSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOqlViewEntitySource creates a OqlViewEntitySource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOqlViewEntitySource() *OqlViewEntitySource { + o := &OqlViewEntitySource{} + o.SetTypeName("DomainModels$OqlViewEntitySource") + o.sourceDocument = property.NewByNameRef[element.Element]("SourceDocument", "DomainModels$ViewEntitySourceDocument") + o.sourceDocument.Bind(&o.Base, 0) + o.oql = property.NewPrimitive[string]("Oql", property.DecodeString) + o.oql.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.sourceDocument, o.oql}) + return o +} + +// NewOqlViewEntitySource creates a new OqlViewEntitySource for user code. Marked dirty (bit 63 = new element). +func NewOqlViewEntitySource() *OqlViewEntitySource { + o := initOqlViewEntitySource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOqlViewValue creates a OqlViewValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOqlViewValue() *OqlViewValue { + o := &OqlViewValue{} + o.SetTypeName("DomainModels$OqlViewValue") + o.reference = property.NewPrimitive[string]("Reference", property.DecodeString) + o.reference.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.reference}) + return o +} + +// NewOqlViewValue creates a new OqlViewValue for user code. Marked dirty (bit 63 = new element). +func NewOqlViewValue() *OqlViewValue { + o := initOqlViewValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRangeRuleInfo creates a RangeRuleInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRangeRuleInfo() *RangeRuleInfo { + o := &RangeRuleInfo{} + o.SetTypeName("DomainModels$RangeRuleInfo") + o.typeOfRange = property.NewEnum[string]("TypeOfRange") + o.typeOfRange.Bind(&o.Base, 0) + o.useMinValue = property.NewPrimitive[bool]("UseMinValue", property.DecodeBool) + o.useMinValue.Bind(&o.Base, 1) + o.useMaxValue = property.NewPrimitive[bool]("UseMaxValue", property.DecodeBool) + o.useMaxValue.Bind(&o.Base, 2) + o.minValue = property.NewPrimitive[string]("MinValue", property.DecodeString) + o.minValue.Bind(&o.Base, 3) + o.maxValue = property.NewPrimitive[string]("MaxValue", property.DecodeString) + o.maxValue.Bind(&o.Base, 4) + o.minAttribute = property.NewByNameRef[element.Element]("MinAttribute", "DomainModels$Attribute") + o.minAttribute.Bind(&o.Base, 5) + o.maxAttribute = property.NewByNameRef[element.Element]("MaxAttribute", "DomainModels$Attribute") + o.maxAttribute.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.typeOfRange, o.useMinValue, o.useMaxValue, o.minValue, o.maxValue, o.minAttribute, o.maxAttribute}) + return o +} + +// NewRangeRuleInfo creates a new RangeRuleInfo for user code. Marked dirty (bit 63 = new element). +func NewRangeRuleInfo() *RangeRuleInfo { + o := initRangeRuleInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRegExRuleInfo creates a RegExRuleInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRegExRuleInfo() *RegExRuleInfo { + o := &RegExRuleInfo{} + o.SetTypeName("DomainModels$RegExRuleInfo") + o.regularExpression = property.NewByNameRef[element.Element]("RegularExpression", "RegularExpressions$RegularExpression") + o.regularExpression.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.regularExpression}) + return o +} + +// NewRegExRuleInfo creates a new RegExRuleInfo for user code. Marked dirty (bit 63 = new element). +func NewRegExRuleInfo() *RegExRuleInfo { + o := initRegExRuleInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRequiredRuleInfo creates a RequiredRuleInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRequiredRuleInfo() *RequiredRuleInfo { + o := &RequiredRuleInfo{} + o.SetTypeName("DomainModels$RequiredRuleInfo") + o.SetProperties([]element.Property{}) + return o +} + +// NewRequiredRuleInfo creates a new RequiredRuleInfo for user code. Marked dirty (bit 63 = new element). +func NewRequiredRuleInfo() *RequiredRuleInfo { + o := initRequiredRuleInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStoredValue creates a StoredValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStoredValue() *StoredValue { + o := &StoredValue{} + o.SetTypeName("DomainModels$StoredValue") + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.defaultValue}) + return o +} + +// NewStoredValue creates a new StoredValue for user code. Marked dirty (bit 63 = new element). +func NewStoredValue() *StoredValue { + o := initStoredValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringAttributeType creates a StringAttributeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringAttributeType() *StringAttributeType { + o := &StringAttributeType{} + o.SetTypeName("DomainModels$StringAttributeType") + o.length = property.NewPrimitive[int32]("Length", property.DecodeInt32) + o.length.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.length}) + return o +} + +// NewStringAttributeType creates a new StringAttributeType for user code. Marked dirty (bit 63 = new element). +func NewStringAttributeType() *StringAttributeType { + o := initStringAttributeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUniqueRuleInfo creates a UniqueRuleInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUniqueRuleInfo() *UniqueRuleInfo { + o := &UniqueRuleInfo{} + o.SetTypeName("DomainModels$UniqueRuleInfo") + o.SetProperties([]element.Property{}) + return o +} + +// NewUniqueRuleInfo creates a new UniqueRuleInfo for user code. Marked dirty (bit 63 = new element). +func NewUniqueRuleInfo() *UniqueRuleInfo { + o := initUniqueRuleInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initValidationRule creates a ValidationRule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initValidationRule() *ValidationRule { + o := &ValidationRule{} + o.SetTypeName("DomainModels$ValidationRule") + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 0) + o.errorMessage = property.NewPart[element.Element]("ErrorMessage") + o.errorMessage.Bind(&o.Base, 1) + o.ruleInfo = property.NewPart[element.Element]("RuleInfo") + o.ruleInfo.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.attribute, o.errorMessage, o.ruleInfo}) + return o +} + +// NewValidationRule creates a new ValidationRule for user code. Marked dirty (bit 63 = new element). +func NewValidationRule() *ValidationRule { + o := initValidationRule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initViewEntitySourceDocument creates a ViewEntitySourceDocument with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initViewEntitySourceDocument() *ViewEntitySourceDocument { + o := &ViewEntitySourceDocument{} + o.SetTypeName("DomainModels$ViewEntitySourceDocument") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.oql = property.NewPrimitive[string]("Oql", property.DecodeString) + o.oql.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.oql}) + return o +} + +// NewViewEntitySourceDocument creates a new ViewEntitySourceDocument for user code. Marked dirty (bit 63 = new element). +func NewViewEntitySourceDocument() *ViewEntitySourceDocument { + o := initViewEntitySourceDocument() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("DomainModels$AccessRule", func() element.Element { + return initAccessRule() + }) + codec.DefaultRegistry.Register("DomainModels$Annotation", func() element.Element { + return initAnnotation() + }) + codec.DefaultRegistry.Register("DomainModels$Association", func() element.Element { + return initAssociation() + }) + codec.DefaultRegistry.Register("DomainModels$AssociationCapabilities", func() element.Element { + return initAssociationCapabilities() + }) + codec.DefaultRegistry.Register("DomainModels$AssociationDeleteBehavior", func() element.Element { + o := initAssociationDeleteBehavior() + o.SetTypeName("DomainModels$AssociationDeleteBehavior") + return o + }) + codec.DefaultRegistry.Register("DomainModels$DeleteBehavior", func() element.Element { + return initAssociationDeleteBehavior() + }) + codec.DefaultRegistry.Register("DomainModels$AssociationRef", func() element.Element { + return initAssociationRef() + }) + codec.DefaultRegistry.Register("DomainModels$Attribute", func() element.Element { + return initAttribute() + }) + codec.DefaultRegistry.Register("DomainModels$AttributeCapabilities", func() element.Element { + return initAttributeCapabilities() + }) + codec.DefaultRegistry.Register("DomainModels$AttributeRef", func() element.Element { + return initAttributeRef() + }) + codec.DefaultRegistry.Register("DomainModels$AutoNumberAttributeType", func() element.Element { + return initAutoNumberAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$BinaryAttributeType", func() element.Element { + return initBinaryAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$BooleanAttributeType", func() element.Element { + return initBooleanAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$CalculatedValue", func() element.Element { + return initCalculatedValue() + }) + codec.DefaultRegistry.Register("DomainModels$CrossAssociation", func() element.Element { + return initCrossAssociation() + }) + codec.DefaultRegistry.Register("DomainModels$CurrencyAttributeType", func() element.Element { + return initCurrencyAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$DateTimeAttributeType", func() element.Element { + return initDateTimeAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$DecimalAttributeType", func() element.Element { + return initDecimalAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$DirectEntityRef", func() element.Element { + return initDirectEntityRef() + }) + codec.DefaultRegistry.Register("DomainModels$DomainModel", func() element.Element { + return initDomainModel() + }) + codec.DefaultRegistry.Register("DomainModels$Entity", func() element.Element { + o := initEntity() + o.SetTypeName("DomainModels$Entity") + return o + }) + codec.DefaultRegistry.Register("DomainModels$EntityImpl", func() element.Element { + return initEntity() + }) + codec.DefaultRegistry.Register("DomainModels$EntityCapabilities", func() element.Element { + return initEntityCapabilities() + }) + codec.DefaultRegistry.Register("DomainModels$EntityKey", func() element.Element { + return initEntityKey() + }) + codec.DefaultRegistry.Register("DomainModels$EntityKeyPart", func() element.Element { + return initEntityKeyPart() + }) + codec.DefaultRegistry.Register("DomainModels$EntityRefStep", func() element.Element { + return initEntityRefStep() + }) + codec.DefaultRegistry.Register("DomainModels$EnumerationAttributeType", func() element.Element { + return initEnumerationAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$EqualsToRuleInfo", func() element.Element { + return initEqualsToRuleInfo() + }) + codec.DefaultRegistry.Register("DomainModels$EventHandler", func() element.Element { + o := initEventHandler() + o.SetTypeName("DomainModels$EventHandler") + return o + }) + codec.DefaultRegistry.Register("DomainModels$EntityEvent", func() element.Element { + return initEventHandler() + }) + codec.DefaultRegistry.Register("DomainModels$FloatAttributeType", func() element.Element { + return initFloatAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$Generalization", func() element.Element { + return initGeneralization() + }) + codec.DefaultRegistry.Register("DomainModels$HashedStringAttributeType", func() element.Element { + return initHashedStringAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$Index", func() element.Element { + o := initIndex() + o.SetTypeName("DomainModels$Index") + return o + }) + codec.DefaultRegistry.Register("DomainModels$EntityIndex", func() element.Element { + return initIndex() + }) + codec.DefaultRegistry.Register("DomainModels$IndexedAttribute", func() element.Element { + return initIndexedAttribute() + }) + codec.DefaultRegistry.Register("DomainModels$IndirectEntityRef", func() element.Element { + return initIndirectEntityRef() + }) + codec.DefaultRegistry.Register("DomainModels$IntegerAttributeType", func() element.Element { + return initIntegerAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$LongAttributeType", func() element.Element { + return initLongAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$MaxLengthRuleInfo", func() element.Element { + return initMaxLengthRuleInfo() + }) + codec.DefaultRegistry.Register("DomainModels$MemberAccess", func() element.Element { + return initMemberAccess() + }) + codec.DefaultRegistry.Register("DomainModels$MultiLanguageAttributeType", func() element.Element { + return initMultiLanguageAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$NoGeneralization", func() element.Element { + return initNoGeneralization() + }) + codec.DefaultRegistry.Register("DomainModels$OqlViewAssociationSource", func() element.Element { + return initOqlViewAssociationSource() + }) + codec.DefaultRegistry.Register("DomainModels$OqlViewEntitySource", func() element.Element { + return initOqlViewEntitySource() + }) + codec.DefaultRegistry.Register("DomainModels$OqlViewValue", func() element.Element { + return initOqlViewValue() + }) + codec.DefaultRegistry.Register("DomainModels$RangeRuleInfo", func() element.Element { + return initRangeRuleInfo() + }) + codec.DefaultRegistry.Register("DomainModels$RegExRuleInfo", func() element.Element { + return initRegExRuleInfo() + }) + codec.DefaultRegistry.Register("DomainModels$RequiredRuleInfo", func() element.Element { + return initRequiredRuleInfo() + }) + codec.DefaultRegistry.Register("DomainModels$StoredValue", func() element.Element { + return initStoredValue() + }) + codec.DefaultRegistry.Register("DomainModels$StringAttributeType", func() element.Element { + return initStringAttributeType() + }) + codec.DefaultRegistry.Register("DomainModels$UniqueRuleInfo", func() element.Element { + return initUniqueRuleInfo() + }) + codec.DefaultRegistry.Register("DomainModels$ValidationRule", func() element.Element { + return initValidationRule() + }) + codec.DefaultRegistry.Register("DomainModels$ViewEntitySourceDocument", func() element.Element { + return initViewEntitySourceDocument() + }) +} diff --git a/modelsdk/gen/domainmodels/version.go b/modelsdk/gen/domainmodels/version.go new file mode 100644 index 00000000..50d87374 --- /dev/null +++ b/modelsdk/gen/domainmodels/version.go @@ -0,0 +1,220 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package domainmodels + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "DomainModels$AccessRule": { + Properties: map[string]version.PropertyVersionInfo{ + "xPathConstraintCaption": {Introduced: "10.5.0"}, + }, + }, + "DomainModels$Annotation": { + Properties: map[string]version.PropertyVersionInfo{ + "exportLevel": {Introduced: "9.15.0"}, + "location": {}, + }, + }, + "DomainModels$AssociationBase": { + Properties: map[string]version.PropertyVersionInfo{ + "capabilities": {Introduced: "8.11.0", Deleted: "9.0.1", Required: true, Public: true}, + "deleteBehavior": {Required: true}, + "documentation": {Public: true}, + "exportLevel": {Introduced: "9.3.0"}, + "name": {Public: true}, + "owner": {Public: true}, + "parent": {Required: true, Public: true}, + "remoteSourceDocument": {Introduced: "8.3.0", Deleted: "8.10.0", Public: true}, + "source": {Introduced: "8.10.0", Public: true}, + "storageFormat": {Introduced: "10.21.0", Public: true}, + "type": {Public: true}, + }, + }, + "DomainModels$Association": { + Properties: map[string]version.PropertyVersionInfo{ + "child": {Required: true, Public: true}, + "parentConnection": {}, + }, + }, + "DomainModels$MemberRef": { + Properties: map[string]version.PropertyVersionInfo{ + "entityRef": {Public: true}, + }, + }, + "DomainModels$AssociationRef": { + Properties: map[string]version.PropertyVersionInfo{ + "association": {Required: true}, + }, + }, + "DomainModels$Attribute": { + Properties: map[string]version.PropertyVersionInfo{ + "capabilities": {Introduced: "8.13.0", Deleted: "9.0.1", Required: true, Public: true}, + "documentation": {Public: true}, + "exportLevel": {Introduced: "9.3.0"}, + "name": {Public: true}, + "type": {Required: true, Public: true}, + "value": {Required: true, Public: true}, + }, + }, + "DomainModels$AttributeCapabilities": { + Properties: map[string]version.PropertyVersionInfo{ + "filterable": {Public: true}, + "sortable": {Public: true}, + }, + }, + "DomainModels$AttributeRef": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Required: true}, + }, + }, + "DomainModels$MappedValue": { + Properties: map[string]version.PropertyVersionInfo{ + "defaultValueDesignTime": {Introduced: "10.4.0"}, + }, + }, + "DomainModels$CrossAssociation": { + Properties: map[string]version.PropertyVersionInfo{ + "child": {Required: true, Public: true}, + }, + }, + "DomainModels$DirectEntityRef": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true}, + }, + }, + "DomainModels$DomainModel": { + Properties: map[string]version.PropertyVersionInfo{ + "associations": {Public: true}, + "crossAssociations": {Public: true}, + "documentation": {Public: true}, + "entities": {Public: true}, + }, + }, + "DomainModels$Entity": { + Properties: map[string]version.PropertyVersionInfo{ + "attributes": {Public: true}, + "capabilities": {Introduced: "8.12.0", Deleted: "9.0.1", Required: true, Public: true}, + "documentation": {Public: true}, + "exportLevel": {Introduced: "9.3.0"}, + "generalization": {Required: true, Public: true}, + "imageData": {Introduced: "9.17.0"}, + "isRemote": {Introduced: "7.17.0", Deleted: "8.10.0", Public: true}, + "location": {Public: true}, + "name": {Public: true}, + "remoteSource": {Introduced: "7.17.0", Deleted: "8.10.0"}, + "remoteSourceDocument": {Introduced: "8.2.0", Deleted: "8.10.0", Public: true}, + "source": {Introduced: "8.10.0", Public: true}, + }, + }, + "DomainModels$EntityImpl": { + Properties: map[string]version.PropertyVersionInfo{ + "attributes": {Public: true}, + "capabilities": {Introduced: "8.12.0", Deleted: "9.0.1", Required: true, Public: true}, + "documentation": {Public: true}, + "exportLevel": {Introduced: "9.3.0"}, + "generalization": {Required: true, Public: true}, + "imageData": {Introduced: "9.17.0"}, + "isRemote": {Introduced: "7.17.0", Deleted: "8.10.0", Public: true}, + "location": {Public: true}, + "name": {Public: true}, + "remoteSource": {Introduced: "7.17.0", Deleted: "8.10.0"}, + "remoteSourceDocument": {Introduced: "8.2.0", Deleted: "8.10.0", Public: true}, + "source": {Introduced: "8.10.0", Public: true}, + }, + }, + "DomainModels$EntityCapabilities": { + Properties: map[string]version.PropertyVersionInfo{ + "countable": {Public: true}, + }, + }, + "DomainModels$EntityKey": { + Properties: map[string]version.PropertyVersionInfo{ + "parts": {Public: true}, + }, + }, + "DomainModels$EntityKeyPart": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "type": {Required: true, Public: true}, + }, + }, + "DomainModels$EntityRefStep": { + Properties: map[string]version.PropertyVersionInfo{ + "association": {Required: true}, + "destinationEntity": {Required: true}, + }, + }, + "DomainModels$EnumerationAttributeType": { + Properties: map[string]version.PropertyVersionInfo{ + "enumeration": {Required: true, Public: true}, + }, + }, + "DomainModels$Generalization": { + Properties: map[string]version.PropertyVersionInfo{ + "generalization": {Required: true, Public: true}, + }, + }, + "DomainModels$Index": { + Properties: map[string]version.PropertyVersionInfo{ + "includeInOffline": {Introduced: "10.12.0"}, + }, + }, + "DomainModels$EntityIndex": { + Properties: map[string]version.PropertyVersionInfo{ + "includeInOffline": {Introduced: "10.12.0"}, + }, + }, + "DomainModels$IndexedAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "ascending": {Introduced: "7.14.0"}, + }, + }, + "DomainModels$IndirectEntityRef": { + Properties: map[string]version.PropertyVersionInfo{ + "steps": {Public: true}, + }, + }, + "DomainModels$NoGeneralization": { + Properties: map[string]version.PropertyVersionInfo{ + "hasChangedBy": {Public: true}, + "hasChangedDate": {Public: true}, + "hasCreatedDate": {Public: true}, + "hasOwner": {Public: true}, + "persistable": {Public: true}, + }, + }, + "DomainModels$OqlViewEntitySource": { + Properties: map[string]version.PropertyVersionInfo{ + "oql": {Deleted: "11.0.0"}, + "sourceDocument": {Introduced: "10.21.0"}, + }, + }, + "DomainModels$RemoteEntitySourceDocument": { + Properties: map[string]version.PropertyVersionInfo{ + "applicationId": {Introduced: "8.11.0", Public: true}, + "catalogUrl": {Introduced: "8.10.0"}, + "description": {Introduced: "8.10.0"}, + "endpointId": {Introduced: "8.14.0", Public: true}, + "environmentType": {Introduced: "8.14.0", Public: true}, + "icon": {Introduced: "8.10.0", Public: true}, + "metadataHash": {Introduced: "8.16.0", Public: true}, + "minimumMxVersion": {Introduced: "8.14.0", Public: true}, + "recommendedMxVersion": {Introduced: "8.14.0", Public: true}, + "serviceName": {Introduced: "8.0.0", Public: true}, + "validated": {Introduced: "9.6.0", Public: true}, + "validatedEntities": {Introduced: "9.8.0", Public: true}, + "version": {Introduced: "8.0.0", Public: true}, + }, + }, + "DomainModels$ValidationRule": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Required: true}, + "errorMessage": {Required: true}, + "ruleInfo": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/enumerations/enums.go b/modelsdk/gen/enumerations/enums.go new file mode 100644 index 00000000..5c580ea1 --- /dev/null +++ b/modelsdk/gen/enumerations/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package enumerations diff --git a/modelsdk/gen/enumerations/refs.go b/modelsdk/gen/enumerations/refs.go new file mode 100644 index 00000000..5cfb786f --- /dev/null +++ b/modelsdk/gen/enumerations/refs.go @@ -0,0 +1,13 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package enumerations + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Enumerations$EnumerationValue", []codec.RefMeta{ + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + }) +} diff --git a/modelsdk/gen/enumerations/types.go b/modelsdk/gen/enumerations/types.go new file mode 100644 index 00000000..444e05f2 --- /dev/null +++ b/modelsdk/gen/enumerations/types.go @@ -0,0 +1,344 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package enumerations + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Condition +// ──────────────────────────────────────────────────────── + +type Condition struct { + element.Base + attributeValue *property.Primitive[string] + editableVisible *property.Primitive[bool] +} + +// AttributeValue returns the value of the attributeValue property. +func (o *Condition) AttributeValue() string { + return o.attributeValue.Get() +} + +// SetAttributeValue sets the value of the attributeValue property. +func (o *Condition) SetAttributeValue(v string) { + o.attributeValue.Set(v) +} + +// EditableVisible returns the value of the editableVisible property. +func (o *Condition) EditableVisible() bool { + return o.editableVisible.Get() +} + +// SetEditableVisible sets the value of the editableVisible property. +func (o *Condition) SetEditableVisible(v bool) { + o.editableVisible.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Condition) InitFromRaw(raw bson.Raw) { + o.attributeValue.Init(raw) + o.editableVisible.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Enumeration +// ──────────────────────────────────────────────────────── + +type Enumeration struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + values *property.PartList[element.Element] + remoteSource *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *Enumeration) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Enumeration) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Enumeration) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Enumeration) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Enumeration) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Enumeration) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Enumeration) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Enumeration) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ValuesItems returns the value of the values property. +func (o *Enumeration) ValuesItems() []element.Element { + return o.values.Items() +} + +// AddValues appends a child element to the values list. +func (o *Enumeration) AddValues(v element.Element) { + o.values.Append(v) +} + +// RemoveValues removes the element at the given index from the values list. +func (o *Enumeration) RemoveValues(index int) { + o.values.Remove(index) +} + +// RemoteSource returns the value of the remoteSource property. +func (o *Enumeration) RemoteSource() element.Element { + return o.remoteSource.Get() +} + +// SetRemoteSource sets the value of the remoteSource property. +func (o *Enumeration) SetRemoteSource(v element.Element) { + o.remoteSource.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Enumeration) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Values"); err == nil { + for _, child := range children { + o.values.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "RemoteSource"); err == nil { + o.remoteSource.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// EnumerationValue +// ──────────────────────────────────────────────────────── + +type EnumerationValue struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + image *property.ByNameRef[element.Element] + remoteValue *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *EnumerationValue) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *EnumerationValue) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *EnumerationValue) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *EnumerationValue) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// ImageQualifiedName returns the value of the image property. +func (o *EnumerationValue) ImageQualifiedName() string { + return o.image.QualifiedName() +} + +// SetImageQualifiedName sets the value of the image property. +func (o *EnumerationValue) SetImageQualifiedName(v string) { + o.image.SetQualifiedName(v) +} + +// RemoteValue returns the value of the remoteValue property. +func (o *EnumerationValue) RemoteValue() element.Element { + return o.remoteValue.Get() +} + +// SetRemoteValue sets the value of the remoteValue property. +func (o *EnumerationValue) SetRemoteValue(v element.Element) { + o.remoteValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EnumerationValue) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if val, err := raw.LookupErr("Image"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.image.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "RemoteValue"); err == nil { + o.remoteValue.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// RemoteEnumerationSource +// ──────────────────────────────────────────────────────── + +type RemoteEnumerationSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RemoteEnumerationSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// RemoteEnumerationValue +// ──────────────────────────────────────────────────────── + +type RemoteEnumerationValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RemoteEnumerationValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initCondition creates a Condition with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCondition() *Condition { + o := &Condition{} + o.SetTypeName("Enumerations$Condition") + o.attributeValue = property.NewPrimitive[string]("AttributeValue", property.DecodeString) + o.attributeValue.Bind(&o.Base, 0) + o.editableVisible = property.NewPrimitive[bool]("EditableVisible", property.DecodeBool) + o.editableVisible.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.attributeValue, o.editableVisible}) + return o +} + +// NewCondition creates a new Condition for user code. Marked dirty (bit 63 = new element). +func NewCondition() *Condition { + o := initCondition() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEnumeration creates a Enumeration with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEnumeration() *Enumeration { + o := &Enumeration{} + o.SetTypeName("Enumerations$Enumeration") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.values = property.NewPartList[element.Element]("Values") + o.values.Bind(&o.Base, 4) + o.remoteSource = property.NewPart[element.Element]("RemoteSource") + o.remoteSource.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.values, o.remoteSource}) + return o +} + +// NewEnumeration creates a new Enumeration for user code. Marked dirty (bit 63 = new element). +func NewEnumeration() *Enumeration { + o := initEnumeration() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEnumerationValue creates a EnumerationValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEnumerationValue() *EnumerationValue { + o := &EnumerationValue{} + o.SetTypeName("Enumerations$EnumerationValue") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.image = property.NewByNameRef[element.Element]("Image", "Images$Image") + o.image.Bind(&o.Base, 2) + o.remoteValue = property.NewPart[element.Element]("RemoteValue") + o.remoteValue.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.name, o.caption, o.image, o.remoteValue}) + return o +} + +// NewEnumerationValue creates a new EnumerationValue for user code. Marked dirty (bit 63 = new element). +func NewEnumerationValue() *EnumerationValue { + o := initEnumerationValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Enumerations$Condition", func() element.Element { + return initCondition() + }) + codec.DefaultRegistry.Register("Enumerations$Enumeration", func() element.Element { + return initEnumeration() + }) + codec.DefaultRegistry.Register("Enumerations$EnumerationValue", func() element.Element { + return initEnumerationValue() + }) +} diff --git a/modelsdk/gen/enumerations/version.go b/modelsdk/gen/enumerations/version.go new file mode 100644 index 00000000..708f49f1 --- /dev/null +++ b/modelsdk/gen/enumerations/version.go @@ -0,0 +1,24 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package enumerations + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Enumerations$Enumeration": { + Properties: map[string]version.PropertyVersionInfo{ + "remoteSource": {Introduced: "10.2.0"}, + "values": {Public: true}, + }, + }, + "Enumerations$EnumerationValue": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + "name": {Public: true}, + "remoteValue": {Introduced: "10.12.0"}, + }, + }, +} diff --git a/modelsdk/gen/exceldataimporter/enums.go b/modelsdk/gen/exceldataimporter/enums.go new file mode 100644 index 00000000..0bb4aabd --- /dev/null +++ b/modelsdk/gen/exceldataimporter/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package exceldataimporter diff --git a/modelsdk/gen/exceldataimporter/refs.go b/modelsdk/gen/exceldataimporter/refs.go new file mode 100644 index 00000000..6e5c4683 --- /dev/null +++ b/modelsdk/gen/exceldataimporter/refs.go @@ -0,0 +1,31 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package exceldataimporter + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("ExcelDataImporter$CSVSheet", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ExcelDataImporter$ColumnAttributeMapping", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ExcelDataImporter$CsvSheetMappingSourceReference", []codec.RefMeta{ + {Prop: "CsvSheet", Kind: codec.RefByName, Target: "ExcelDataImporter$CSVSheet"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ExcelDataImporter$ExcelSheet", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ExcelDataImporter$ExcelSheetMappingSourceReference", []codec.RefMeta{ + {Prop: "ExcelSheet", Kind: codec.RefByName, Target: "ExcelDataImporter$ExcelSheet"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ExcelDataImporter$ImportExcelDataAction", []codec.RefMeta{ + {Prop: "Template", Kind: codec.RefByName, Target: "ExcelDataImporter$Template"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ExcelDataImporter$Sheet", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) +} diff --git a/modelsdk/gen/exceldataimporter/types.go b/modelsdk/gen/exceldataimporter/types.go new file mode 100644 index 00000000..0534bb44 --- /dev/null +++ b/modelsdk/gen/exceldataimporter/types.go @@ -0,0 +1,1412 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package exceldataimporter + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// CSVSheet +// ──────────────────────────────────────────────────────── + +type CSVSheet struct { + element.Base + name *property.Primitive[string] + delimiter *property.Primitive[string] + quoteChar *property.Primitive[string] + escapeChar *property.Primitive[string] + headerIncluded *property.Primitive[bool] + entity *property.ByNameRef[element.Element] + columnAttributeMappings *property.PartList[element.Element] + csvRootElement *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *CSVSheet) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CSVSheet) SetName(v string) { + o.name.Set(v) +} + +// Delimiter returns the value of the delimiter property. +func (o *CSVSheet) Delimiter() string { + return o.delimiter.Get() +} + +// SetDelimiter sets the value of the delimiter property. +func (o *CSVSheet) SetDelimiter(v string) { + o.delimiter.Set(v) +} + +// QuoteChar returns the value of the quoteChar property. +func (o *CSVSheet) QuoteChar() string { + return o.quoteChar.Get() +} + +// SetQuoteChar sets the value of the quoteChar property. +func (o *CSVSheet) SetQuoteChar(v string) { + o.quoteChar.Set(v) +} + +// EscapeChar returns the value of the escapeChar property. +func (o *CSVSheet) EscapeChar() string { + return o.escapeChar.Get() +} + +// SetEscapeChar sets the value of the escapeChar property. +func (o *CSVSheet) SetEscapeChar(v string) { + o.escapeChar.Set(v) +} + +// HeaderIncluded returns the value of the headerIncluded property. +func (o *CSVSheet) HeaderIncluded() bool { + return o.headerIncluded.Get() +} + +// SetHeaderIncluded sets the value of the headerIncluded property. +func (o *CSVSheet) SetHeaderIncluded(v bool) { + o.headerIncluded.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *CSVSheet) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *CSVSheet) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ColumnAttributeMappingsItems returns the value of the columnAttributeMappings property. +func (o *CSVSheet) ColumnAttributeMappingsItems() []element.Element { + return o.columnAttributeMappings.Items() +} + +// AddColumnAttributeMappings appends a child element to the columnAttributeMappings list. +func (o *CSVSheet) AddColumnAttributeMappings(v element.Element) { + o.columnAttributeMappings.Append(v) +} + +// RemoveColumnAttributeMappings removes the element at the given index from the columnAttributeMappings list. +func (o *CSVSheet) RemoveColumnAttributeMappings(index int) { + o.columnAttributeMappings.Remove(index) +} + +// CsvRootElement returns the value of the csvRootElement property. +func (o *CSVSheet) CsvRootElement() element.Element { + return o.csvRootElement.Get() +} + +// SetCsvRootElement sets the value of the csvRootElement property. +func (o *CSVSheet) SetCsvRootElement(v element.Element) { + o.csvRootElement.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CSVSheet) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.delimiter.Init(raw) + o.quoteChar.Init(raw) + o.escapeChar.Init(raw) + o.headerIncluded.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "ColumnAttributeMappings"); err == nil { + for _, child := range children { + o.columnAttributeMappings.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "CsvRootElement"); err == nil { + o.csvRootElement.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TemplateContents +// ──────────────────────────────────────────────────────── + +type TemplateContents struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TemplateContents) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CSVTemplateContents +// ──────────────────────────────────────────────────────── + +type CSVTemplateContents struct { + element.Base + sheet *property.Part[element.Element] +} + +// Sheet returns the value of the sheet property. +func (o *CSVTemplateContents) Sheet() element.Element { + return o.sheet.Get() +} + +// SetSheet sets the value of the sheet property. +func (o *CSVTemplateContents) SetSheet(v element.Element) { + o.sheet.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CSVTemplateContents) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Sheet"); err == nil { + o.sheet.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ColumnAttributeMapping +// ──────────────────────────────────────────────────────── + +type ColumnAttributeMapping struct { + element.Base + reference *property.Part[element.Element] + attribute *property.ByNameRef[element.Element] +} + +// Reference returns the value of the reference property. +func (o *ColumnAttributeMapping) Reference() element.Element { + return o.reference.Get() +} + +// SetReference sets the value of the reference property. +func (o *ColumnAttributeMapping) SetReference(v element.Element) { + o.reference.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ColumnAttributeMapping) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ColumnAttributeMapping) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ColumnAttributeMapping) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Reference"); err == nil { + o.reference.SetFromDecode(child) + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// CsvSheetMappingSourceReference +// ──────────────────────────────────────────────────────── + +type CsvSheetMappingSourceReference struct { + element.Base + csvSheet *property.ByNameRef[element.Element] +} + +// CsvSheetQualifiedName returns the value of the csvSheet property. +func (o *CsvSheetMappingSourceReference) CsvSheetQualifiedName() string { + return o.csvSheet.QualifiedName() +} + +// SetCsvSheetQualifiedName sets the value of the csvSheet property. +func (o *CsvSheetMappingSourceReference) SetCsvSheetQualifiedName(v string) { + o.csvSheet.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CsvSheetMappingSourceReference) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("CsvSheet"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.csvSheet.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// DataImporterElement +// ──────────────────────────────────────────────────────── + +type DataImporterElement struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] + originalValues *property.Primitive[string] +} + +// ElementType returns the value of the elementType property. +func (o *DataImporterElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *DataImporterElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *DataImporterElement) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *DataImporterElement) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *DataImporterElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *DataImporterElement) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *DataImporterElement) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *DataImporterElement) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *DataImporterElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *DataImporterElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *DataImporterElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *DataImporterElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *DataImporterElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *DataImporterElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *DataImporterElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *DataImporterElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *DataImporterElement) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *DataImporterElement) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *DataImporterElement) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *DataImporterElement) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *DataImporterElement) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *DataImporterElement) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *DataImporterElement) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *DataImporterElement) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *DataImporterElement) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *DataImporterElement) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *DataImporterElement) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *DataImporterElement) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *DataImporterElement) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *DataImporterElement) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *DataImporterElement) RemoveChildren(index int) { + o.children.Remove(index) +} + +// OriginalValues returns the value of the originalValues property. +func (o *DataImporterElement) OriginalValues() string { + return o.originalValues.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataImporterElement) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } + o.originalValues.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ExcelSheet +// ──────────────────────────────────────────────────────── + +type ExcelSheet struct { + element.Base + name *property.Primitive[string] + reference *property.Part[element.Element] + headerRowStartsAt *property.Primitive[int32] + dataRowStartsAt *property.Primitive[int32] + entity *property.ByNameRef[element.Element] + columnAttributeMappings *property.PartList[element.Element] + excelRootElement *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *ExcelSheet) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ExcelSheet) SetName(v string) { + o.name.Set(v) +} + +// Reference returns the value of the reference property. +func (o *ExcelSheet) Reference() element.Element { + return o.reference.Get() +} + +// SetReference sets the value of the reference property. +func (o *ExcelSheet) SetReference(v element.Element) { + o.reference.Set(v) +} + +// HeaderRowStartsAt returns the value of the headerRowStartsAt property. +func (o *ExcelSheet) HeaderRowStartsAt() int32 { + return o.headerRowStartsAt.Get() +} + +// SetHeaderRowStartsAt sets the value of the headerRowStartsAt property. +func (o *ExcelSheet) SetHeaderRowStartsAt(v int32) { + o.headerRowStartsAt.Set(v) +} + +// DataRowStartsAt returns the value of the dataRowStartsAt property. +func (o *ExcelSheet) DataRowStartsAt() int32 { + return o.dataRowStartsAt.Get() +} + +// SetDataRowStartsAt sets the value of the dataRowStartsAt property. +func (o *ExcelSheet) SetDataRowStartsAt(v int32) { + o.dataRowStartsAt.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ExcelSheet) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ExcelSheet) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ColumnAttributeMappingsItems returns the value of the columnAttributeMappings property. +func (o *ExcelSheet) ColumnAttributeMappingsItems() []element.Element { + return o.columnAttributeMappings.Items() +} + +// AddColumnAttributeMappings appends a child element to the columnAttributeMappings list. +func (o *ExcelSheet) AddColumnAttributeMappings(v element.Element) { + o.columnAttributeMappings.Append(v) +} + +// RemoveColumnAttributeMappings removes the element at the given index from the columnAttributeMappings list. +func (o *ExcelSheet) RemoveColumnAttributeMappings(index int) { + o.columnAttributeMappings.Remove(index) +} + +// ExcelRootElement returns the value of the excelRootElement property. +func (o *ExcelSheet) ExcelRootElement() element.Element { + return o.excelRootElement.Get() +} + +// SetExcelRootElement sets the value of the excelRootElement property. +func (o *ExcelSheet) SetExcelRootElement(v element.Element) { + o.excelRootElement.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExcelSheet) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Reference"); err == nil { + o.reference.SetFromDecode(child) + } + o.headerRowStartsAt.Init(raw) + o.dataRowStartsAt.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "ColumnAttributeMappings"); err == nil { + for _, child := range children { + o.columnAttributeMappings.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ExcelRootElement"); err == nil { + o.excelRootElement.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ExcelSheetMappingSourceReference +// ──────────────────────────────────────────────────────── + +type ExcelSheetMappingSourceReference struct { + element.Base + excelSheet *property.ByNameRef[element.Element] +} + +// ExcelSheetQualifiedName returns the value of the excelSheet property. +func (o *ExcelSheetMappingSourceReference) ExcelSheetQualifiedName() string { + return o.excelSheet.QualifiedName() +} + +// SetExcelSheetQualifiedName sets the value of the excelSheet property. +func (o *ExcelSheetMappingSourceReference) SetExcelSheetQualifiedName(v string) { + o.excelSheet.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExcelSheetMappingSourceReference) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ExcelSheet"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.excelSheet.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ExcelTemplateContents +// ──────────────────────────────────────────────────────── + +type ExcelTemplateContents struct { + element.Base + sheets *property.PartList[element.Element] +} + +// SheetsItems returns the value of the sheets property. +func (o *ExcelTemplateContents) SheetsItems() []element.Element { + return o.sheets.Items() +} + +// AddSheets appends a child element to the sheets list. +func (o *ExcelTemplateContents) AddSheets(v element.Element) { + o.sheets.Append(v) +} + +// RemoveSheets removes the element at the given index from the sheets list. +func (o *ExcelTemplateContents) RemoveSheets(index int) { + o.sheets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExcelTemplateContents) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Sheets"); err == nil { + for _, child := range children { + o.sheets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ImportExcelDataAction +// ──────────────────────────────────────────────────────── + +type ImportExcelDataAction struct { + element.Base + errorHandlingType *property.Enum[string] + template *property.ByNameRef[element.Element] + fileVariableName *property.Primitive[string] + outputVariableName *property.Primitive[string] + inputFileVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ImportExcelDataAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ImportExcelDataAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// TemplateQualifiedName returns the value of the template property. +func (o *ImportExcelDataAction) TemplateQualifiedName() string { + return o.template.QualifiedName() +} + +// SetTemplateQualifiedName sets the value of the template property. +func (o *ImportExcelDataAction) SetTemplateQualifiedName(v string) { + o.template.SetQualifiedName(v) +} + +// FileVariableName returns the value of the fileVariableName property. +func (o *ImportExcelDataAction) FileVariableName() string { + return o.fileVariableName.Get() +} + +// SetFileVariableName sets the value of the fileVariableName property. +func (o *ImportExcelDataAction) SetFileVariableName(v string) { + o.fileVariableName.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *ImportExcelDataAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *ImportExcelDataAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InputFileVariableName returns the value of the inputFileVariableName property. +func (o *ImportExcelDataAction) InputFileVariableName() string { + return o.inputFileVariableName.Get() +} + +// SetInputFileVariableName sets the value of the inputFileVariableName property. +func (o *ImportExcelDataAction) SetInputFileVariableName(v string) { + o.inputFileVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportExcelDataAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.errorHandlingType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Template"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.template.SetFromDecode(s) + } + } + o.fileVariableName.Init(raw) + o.outputVariableName.Init(raw) + o.inputFileVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Reference +// ──────────────────────────────────────────────────────── + +type Reference struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Reference) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// IndexReference +// ──────────────────────────────────────────────────────── + +type IndexReference struct { + element.Base + referencedIndex *property.Primitive[int32] +} + +// ReferencedIndex returns the value of the referencedIndex property. +func (o *IndexReference) ReferencedIndex() int32 { + return o.referencedIndex.Get() +} + +// SetReferencedIndex sets the value of the referencedIndex property. +func (o *IndexReference) SetReferencedIndex(v int32) { + o.referencedIndex.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IndexReference) InitFromRaw(raw bson.Raw) { + o.referencedIndex.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// NameReference +// ──────────────────────────────────────────────────────── + +type NameReference struct { + element.Base + referencedName *property.Primitive[string] +} + +// ReferencedName returns the value of the referencedName property. +func (o *NameReference) ReferencedName() string { + return o.referencedName.Get() +} + +// SetReferencedName sets the value of the referencedName property. +func (o *NameReference) SetReferencedName(v string) { + o.referencedName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NameReference) InitFromRaw(raw bson.Raw) { + o.referencedName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Sheet +// ──────────────────────────────────────────────────────── + +type Sheet struct { + element.Base + reference *property.Part[element.Element] + headerRowStartsAt *property.Primitive[int32] + dataRowStartsAt *property.Primitive[int32] + entity *property.ByNameRef[element.Element] + columnAttributeMappings *property.PartList[element.Element] +} + +// Reference returns the value of the reference property. +func (o *Sheet) Reference() element.Element { + return o.reference.Get() +} + +// SetReference sets the value of the reference property. +func (o *Sheet) SetReference(v element.Element) { + o.reference.Set(v) +} + +// HeaderRowStartsAt returns the value of the headerRowStartsAt property. +func (o *Sheet) HeaderRowStartsAt() int32 { + return o.headerRowStartsAt.Get() +} + +// SetHeaderRowStartsAt sets the value of the headerRowStartsAt property. +func (o *Sheet) SetHeaderRowStartsAt(v int32) { + o.headerRowStartsAt.Set(v) +} + +// DataRowStartsAt returns the value of the dataRowStartsAt property. +func (o *Sheet) DataRowStartsAt() int32 { + return o.dataRowStartsAt.Get() +} + +// SetDataRowStartsAt sets the value of the dataRowStartsAt property. +func (o *Sheet) SetDataRowStartsAt(v int32) { + o.dataRowStartsAt.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *Sheet) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *Sheet) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ColumnAttributeMappingsItems returns the value of the columnAttributeMappings property. +func (o *Sheet) ColumnAttributeMappingsItems() []element.Element { + return o.columnAttributeMappings.Items() +} + +// AddColumnAttributeMappings appends a child element to the columnAttributeMappings list. +func (o *Sheet) AddColumnAttributeMappings(v element.Element) { + o.columnAttributeMappings.Append(v) +} + +// RemoveColumnAttributeMappings removes the element at the given index from the columnAttributeMappings list. +func (o *Sheet) RemoveColumnAttributeMappings(index int) { + o.columnAttributeMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Sheet) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Reference"); err == nil { + o.reference.SetFromDecode(child) + } + o.headerRowStartsAt.Init(raw) + o.dataRowStartsAt.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "ColumnAttributeMappings"); err == nil { + for _, child := range children { + o.columnAttributeMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Template +// ──────────────────────────────────────────────────────── + +type Template struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + templateName *property.Primitive[string] + sheets *property.PartList[element.Element] + contents *property.Part[element.Element] + fileName *property.Primitive[string] + useAsMappingSource *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *Template) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Template) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Template) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Template) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Template) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Template) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Template) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Template) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// TemplateName returns the value of the templateName property. +func (o *Template) TemplateName() string { + return o.templateName.Get() +} + +// SetTemplateName sets the value of the templateName property. +func (o *Template) SetTemplateName(v string) { + o.templateName.Set(v) +} + +// SheetsItems returns the value of the sheets property. +func (o *Template) SheetsItems() []element.Element { + return o.sheets.Items() +} + +// AddSheets appends a child element to the sheets list. +func (o *Template) AddSheets(v element.Element) { + o.sheets.Append(v) +} + +// RemoveSheets removes the element at the given index from the sheets list. +func (o *Template) RemoveSheets(index int) { + o.sheets.Remove(index) +} + +// Contents returns the value of the contents property. +func (o *Template) Contents() element.Element { + return o.contents.Get() +} + +// SetContents sets the value of the contents property. +func (o *Template) SetContents(v element.Element) { + o.contents.Set(v) +} + +// FileName returns the value of the fileName property. +func (o *Template) FileName() string { + return o.fileName.Get() +} + +// SetFileName sets the value of the fileName property. +func (o *Template) SetFileName(v string) { + o.fileName.Set(v) +} + +// UseAsMappingSource returns the value of the useAsMappingSource property. +func (o *Template) UseAsMappingSource() bool { + return o.useAsMappingSource.Get() +} + +// SetUseAsMappingSource sets the value of the useAsMappingSource property. +func (o *Template) SetUseAsMappingSource(v bool) { + o.useAsMappingSource.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Template) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.templateName.Init(raw) + if children, err := codec.DecodeChildren(raw, "Sheets"); err == nil { + for _, child := range children { + o.sheets.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Contents"); err == nil { + o.contents.SetFromDecode(child) + } + o.fileName.Init(raw) + o.useAsMappingSource.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initCSVSheet creates a CSVSheet with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCSVSheet() *CSVSheet { + o := &CSVSheet{} + o.SetTypeName("ExcelDataImporter$CSVSheet") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.delimiter = property.NewPrimitive[string]("Delimiter", property.DecodeString) + o.delimiter.Bind(&o.Base, 1) + o.quoteChar = property.NewPrimitive[string]("QuoteChar", property.DecodeString) + o.quoteChar.Bind(&o.Base, 2) + o.escapeChar = property.NewPrimitive[string]("EscapeChar", property.DecodeString) + o.escapeChar.Bind(&o.Base, 3) + o.headerIncluded = property.NewPrimitive[bool]("HeaderIncluded", property.DecodeBool) + o.headerIncluded.Bind(&o.Base, 4) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 5) + o.columnAttributeMappings = property.NewPartList[element.Element]("ColumnAttributeMappings") + o.columnAttributeMappings.Bind(&o.Base, 6) + o.csvRootElement = property.NewPart[element.Element]("CsvRootElement") + o.csvRootElement.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.delimiter, o.quoteChar, o.escapeChar, o.headerIncluded, o.entity, o.columnAttributeMappings, o.csvRootElement}) + return o +} + +// NewCSVSheet creates a new CSVSheet for user code. Marked dirty (bit 63 = new element). +func NewCSVSheet() *CSVSheet { + o := initCSVSheet() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCSVTemplateContents creates a CSVTemplateContents with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCSVTemplateContents() *CSVTemplateContents { + o := &CSVTemplateContents{} + o.SetTypeName("ExcelDataImporter$CSVTemplateContents") + o.sheet = property.NewPart[element.Element]("Sheet") + o.sheet.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.sheet}) + return o +} + +// NewCSVTemplateContents creates a new CSVTemplateContents for user code. Marked dirty (bit 63 = new element). +func NewCSVTemplateContents() *CSVTemplateContents { + o := initCSVTemplateContents() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initColumnAttributeMapping creates a ColumnAttributeMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initColumnAttributeMapping() *ColumnAttributeMapping { + o := &ColumnAttributeMapping{} + o.SetTypeName("ExcelDataImporter$ColumnAttributeMapping") + o.reference = property.NewPart[element.Element]("Reference") + o.reference.Bind(&o.Base, 0) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.reference, o.attribute}) + return o +} + +// NewColumnAttributeMapping creates a new ColumnAttributeMapping for user code. Marked dirty (bit 63 = new element). +func NewColumnAttributeMapping() *ColumnAttributeMapping { + o := initColumnAttributeMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCsvSheetMappingSourceReference creates a CsvSheetMappingSourceReference with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCsvSheetMappingSourceReference() *CsvSheetMappingSourceReference { + o := &CsvSheetMappingSourceReference{} + o.SetTypeName("ExcelDataImporter$CsvSheetMappingSourceReference") + o.csvSheet = property.NewByNameRef[element.Element]("CsvSheet", "ExcelDataImporter$CSVSheet") + o.csvSheet.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.csvSheet}) + return o +} + +// NewCsvSheetMappingSourceReference creates a new CsvSheetMappingSourceReference for user code. Marked dirty (bit 63 = new element). +func NewCsvSheetMappingSourceReference() *CsvSheetMappingSourceReference { + o := initCsvSheetMappingSourceReference() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataImporterElement creates a DataImporterElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataImporterElement() *DataImporterElement { + o := &DataImporterElement{} + o.SetTypeName("ExcelDataImporter$DataImporterElement") + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 0) + o.primitiveType = property.NewEnum[string]("PrimitiveType") + o.primitiveType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 3) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 4) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 5) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 6) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 7) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 8) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 9) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 10) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 11) + o.errorMessage = property.NewPrimitive[string]("ErrorMessage", property.DecodeString) + o.errorMessage.Bind(&o.Base, 12) + o.warningMessage = property.NewPrimitive[string]("WarningMessage", property.DecodeString) + o.warningMessage.Bind(&o.Base, 13) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 14) + o.originalValues = property.NewPrimitive[string]("OriginalValues", property.DecodeString) + o.originalValues.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.elementType, o.primitiveType, o.path, o.isDefaultType, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.exposedItemName, o.maxLength, o.fractionDigits, o.totalDigits, o.errorMessage, o.warningMessage, o.children, o.originalValues}) + return o +} + +// NewDataImporterElement creates a new DataImporterElement for user code. Marked dirty (bit 63 = new element). +func NewDataImporterElement() *DataImporterElement { + o := initDataImporterElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExcelSheet creates a ExcelSheet with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExcelSheet() *ExcelSheet { + o := &ExcelSheet{} + o.SetTypeName("ExcelDataImporter$ExcelSheet") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.reference = property.NewPart[element.Element]("Reference") + o.reference.Bind(&o.Base, 1) + o.headerRowStartsAt = property.NewPrimitive[int32]("HeaderRowStartsAt", property.DecodeInt32) + o.headerRowStartsAt.Bind(&o.Base, 2) + o.dataRowStartsAt = property.NewPrimitive[int32]("DataRowStartsAt", property.DecodeInt32) + o.dataRowStartsAt.Bind(&o.Base, 3) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 4) + o.columnAttributeMappings = property.NewPartList[element.Element]("ColumnAttributeMappings") + o.columnAttributeMappings.Bind(&o.Base, 5) + o.excelRootElement = property.NewPart[element.Element]("ExcelRootElement") + o.excelRootElement.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.reference, o.headerRowStartsAt, o.dataRowStartsAt, o.entity, o.columnAttributeMappings, o.excelRootElement}) + return o +} + +// NewExcelSheet creates a new ExcelSheet for user code. Marked dirty (bit 63 = new element). +func NewExcelSheet() *ExcelSheet { + o := initExcelSheet() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExcelSheetMappingSourceReference creates a ExcelSheetMappingSourceReference with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExcelSheetMappingSourceReference() *ExcelSheetMappingSourceReference { + o := &ExcelSheetMappingSourceReference{} + o.SetTypeName("ExcelDataImporter$ExcelSheetMappingSourceReference") + o.excelSheet = property.NewByNameRef[element.Element]("ExcelSheet", "ExcelDataImporter$ExcelSheet") + o.excelSheet.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.excelSheet}) + return o +} + +// NewExcelSheetMappingSourceReference creates a new ExcelSheetMappingSourceReference for user code. Marked dirty (bit 63 = new element). +func NewExcelSheetMappingSourceReference() *ExcelSheetMappingSourceReference { + o := initExcelSheetMappingSourceReference() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExcelTemplateContents creates a ExcelTemplateContents with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExcelTemplateContents() *ExcelTemplateContents { + o := &ExcelTemplateContents{} + o.SetTypeName("ExcelDataImporter$ExcelTemplateContents") + o.sheets = property.NewPartList[element.Element]("Sheets") + o.sheets.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.sheets}) + return o +} + +// NewExcelTemplateContents creates a new ExcelTemplateContents for user code. Marked dirty (bit 63 = new element). +func NewExcelTemplateContents() *ExcelTemplateContents { + o := initExcelTemplateContents() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImportExcelDataAction creates a ImportExcelDataAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportExcelDataAction() *ImportExcelDataAction { + o := &ImportExcelDataAction{} + o.SetTypeName("ExcelDataImporter$ImportExcelDataAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.template = property.NewByNameRef[element.Element]("Template", "ExcelDataImporter$Template") + o.template.Bind(&o.Base, 1) + o.fileVariableName = property.NewPrimitive[string]("FileVariableName", property.DecodeString) + o.fileVariableName.Bind(&o.Base, 2) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 3) + o.inputFileVariableName = property.NewPrimitive[string]("InputFileVariableName", property.DecodeString) + o.inputFileVariableName.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.template, o.fileVariableName, o.outputVariableName, o.inputFileVariableName}) + return o +} + +// NewImportExcelDataAction creates a new ImportExcelDataAction for user code. Marked dirty (bit 63 = new element). +func NewImportExcelDataAction() *ImportExcelDataAction { + o := initImportExcelDataAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIndexReference creates a IndexReference with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIndexReference() *IndexReference { + o := &IndexReference{} + o.SetTypeName("ExcelDataImporter$IndexReference") + o.referencedIndex = property.NewPrimitive[int32]("ReferencedIndex", property.DecodeInt32) + o.referencedIndex.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.referencedIndex}) + return o +} + +// NewIndexReference creates a new IndexReference for user code. Marked dirty (bit 63 = new element). +func NewIndexReference() *IndexReference { + o := initIndexReference() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNameReference creates a NameReference with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNameReference() *NameReference { + o := &NameReference{} + o.SetTypeName("ExcelDataImporter$NameReference") + o.referencedName = property.NewPrimitive[string]("ReferencedName", property.DecodeString) + o.referencedName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.referencedName}) + return o +} + +// NewNameReference creates a new NameReference for user code. Marked dirty (bit 63 = new element). +func NewNameReference() *NameReference { + o := initNameReference() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSheet creates a Sheet with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSheet() *Sheet { + o := &Sheet{} + o.SetTypeName("ExcelDataImporter$Sheet") + o.reference = property.NewPart[element.Element]("Reference") + o.reference.Bind(&o.Base, 0) + o.headerRowStartsAt = property.NewPrimitive[int32]("HeaderRowStartsAt", property.DecodeInt32) + o.headerRowStartsAt.Bind(&o.Base, 1) + o.dataRowStartsAt = property.NewPrimitive[int32]("DataRowStartsAt", property.DecodeInt32) + o.dataRowStartsAt.Bind(&o.Base, 2) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 3) + o.columnAttributeMappings = property.NewPartList[element.Element]("ColumnAttributeMappings") + o.columnAttributeMappings.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.reference, o.headerRowStartsAt, o.dataRowStartsAt, o.entity, o.columnAttributeMappings}) + return o +} + +// NewSheet creates a new Sheet for user code. Marked dirty (bit 63 = new element). +func NewSheet() *Sheet { + o := initSheet() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTemplate creates a Template with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTemplate() *Template { + o := &Template{} + o.SetTypeName("ExcelDataImporter$Template") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.templateName = property.NewPrimitive[string]("TemplateName", property.DecodeString) + o.templateName.Bind(&o.Base, 4) + o.sheets = property.NewPartList[element.Element]("Sheets") + o.sheets.Bind(&o.Base, 5) + o.contents = property.NewPart[element.Element]("Contents") + o.contents.Bind(&o.Base, 6) + o.fileName = property.NewPrimitive[string]("FileName", property.DecodeString) + o.fileName.Bind(&o.Base, 7) + o.useAsMappingSource = property.NewPrimitive[bool]("UseAsMappingSource", property.DecodeBool) + o.useAsMappingSource.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.templateName, o.sheets, o.contents, o.fileName, o.useAsMappingSource}) + return o +} + +// NewTemplate creates a new Template for user code. Marked dirty (bit 63 = new element). +func NewTemplate() *Template { + o := initTemplate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("ExcelDataImporter$CSVSheet", func() element.Element { + return initCSVSheet() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$CSVTemplateContents", func() element.Element { + return initCSVTemplateContents() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$ColumnAttributeMapping", func() element.Element { + return initColumnAttributeMapping() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$CsvSheetMappingSourceReference", func() element.Element { + return initCsvSheetMappingSourceReference() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$DataImporterElement", func() element.Element { + return initDataImporterElement() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$ExcelSheet", func() element.Element { + return initExcelSheet() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$ExcelSheetMappingSourceReference", func() element.Element { + return initExcelSheetMappingSourceReference() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$ExcelTemplateContents", func() element.Element { + return initExcelTemplateContents() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$ImportExcelDataAction", func() element.Element { + return initImportExcelDataAction() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$IndexReference", func() element.Element { + return initIndexReference() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$NameReference", func() element.Element { + return initNameReference() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$Sheet", func() element.Element { + return initSheet() + }) + codec.DefaultRegistry.Register("ExcelDataImporter$Template", func() element.Element { + return initTemplate() + }) +} diff --git a/modelsdk/gen/exceldataimporter/version.go b/modelsdk/gen/exceldataimporter/version.go new file mode 100644 index 00000000..e0081622 --- /dev/null +++ b/modelsdk/gen/exceldataimporter/version.go @@ -0,0 +1,70 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package exceldataimporter + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "ExcelDataImporter$CSVSheet": { + Properties: map[string]version.PropertyVersionInfo{ + "csvRootElement": {Introduced: "10.15.0", Required: true}, + "entity": {}, + }, + }, + "ExcelDataImporter$CSVTemplateContents": { + Properties: map[string]version.PropertyVersionInfo{ + "sheet": {Required: true, Public: true}, + }, + }, + "ExcelDataImporter$ColumnAttributeMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Required: true}, + "reference": {Required: true}, + }, + }, + "ExcelDataImporter$CsvSheetMappingSourceReference": { + Properties: map[string]version.PropertyVersionInfo{ + "csvSheet": {Required: true}, + }, + }, + "ExcelDataImporter$ExcelSheet": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {}, + "excelRootElement": {Introduced: "10.15.0", Required: true}, + "reference": {Required: true}, + }, + }, + "ExcelDataImporter$ExcelSheetMappingSourceReference": { + Properties: map[string]version.PropertyVersionInfo{ + "excelSheet": {Required: true}, + }, + }, + "ExcelDataImporter$ExcelTemplateContents": { + Properties: map[string]version.PropertyVersionInfo{ + "sheets": {Public: true}, + }, + }, + "ExcelDataImporter$ImportExcelDataAction": { + Properties: map[string]version.PropertyVersionInfo{ + "fileVariableName": {Deleted: "11.2.0"}, + "inputFileVariableName": {Introduced: "11.2.0"}, + "template": {}, + }, + }, + "ExcelDataImporter$Sheet": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Introduced: "10.2.0", Required: true}, + "reference": {Required: true}, + }, + }, + "ExcelDataImporter$Template": { + Properties: map[string]version.PropertyVersionInfo{ + "contents": {Introduced: "10.6.0", Public: true}, + "sheets": {Deleted: "10.6.0"}, + "useAsMappingSource": {Introduced: "10.15.0"}, + }, + }, +} diff --git a/modelsdk/gen/exportmappings/enums.go b/modelsdk/gen/exportmappings/enums.go new file mode 100644 index 00000000..2dbbf52b --- /dev/null +++ b/modelsdk/gen/exportmappings/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package exportmappings diff --git a/modelsdk/gen/exportmappings/refs.go b/modelsdk/gen/exportmappings/refs.go new file mode 100644 index 00000000..9d56ecd8 --- /dev/null +++ b/modelsdk/gen/exportmappings/refs.go @@ -0,0 +1,32 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package exportmappings + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("ExportMappings$ExportMapping", []codec.RefMeta{ + {Prop: "XmlSchema", Kind: codec.RefByName, Target: "XmlSchemas$XmlSchema"}, + {Prop: "JsonStructure", Kind: codec.RefByName, Target: "JsonStructures$JsonStructure"}, + {Prop: "ImportedWebService", Kind: codec.RefByName, Target: "WebServices$ImportedWebService"}, + {Prop: "MessageDefinition", Kind: codec.RefByName, Target: "MessageDefinitions$MessageDefinition"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ExportMappings$ExportObjectMappingElement", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ExportMappings$ObjectMappingElement", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ExportMappings$ExportValueMappingElement", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Converter", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ExportMappings$ValueMappingElement", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Converter", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) +} diff --git a/modelsdk/gen/exportmappings/types.go b/modelsdk/gen/exportmappings/types.go new file mode 100644 index 00000000..8ace8e59 --- /dev/null +++ b/modelsdk/gen/exportmappings/types.go @@ -0,0 +1,1021 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package exportmappings + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// ExportMapping +// ──────────────────────────────────────────────────────── + +type ExportMapping struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + rootMappingElements *property.PartList[element.Element] + xmlSchema *property.ByNameRef[element.Element] + jsonStructure *property.ByNameRef[element.Element] + rootElementName *property.Primitive[string] + importedWebService *property.ByNameRef[element.Element] + serviceName *property.Primitive[string] + operationName *property.Primitive[string] + messageDefinition *property.ByNameRef[element.Element] + mappingSourceReference *property.Part[element.Element] + publicName *property.Primitive[string] + parameterName *property.Primitive[string] + parameterTypeName *property.Primitive[string] + isHeader *property.Primitive[bool] + nullValueOption *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *ExportMapping) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ExportMapping) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ExportMapping) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ExportMapping) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ExportMapping) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ExportMapping) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ExportMapping) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ExportMapping) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// RootMappingElementsItems returns the value of the rootMappingElements property. +func (o *ExportMapping) RootMappingElementsItems() []element.Element { + return o.rootMappingElements.Items() +} + +// AddRootMappingElements appends a child element to the rootMappingElements list. +func (o *ExportMapping) AddRootMappingElements(v element.Element) { + o.rootMappingElements.Append(v) +} + +// RemoveRootMappingElements removes the element at the given index from the rootMappingElements list. +func (o *ExportMapping) RemoveRootMappingElements(index int) { + o.rootMappingElements.Remove(index) +} + +// XmlSchemaQualifiedName returns the value of the xmlSchema property. +func (o *ExportMapping) XmlSchemaQualifiedName() string { + return o.xmlSchema.QualifiedName() +} + +// SetXmlSchemaQualifiedName sets the value of the xmlSchema property. +func (o *ExportMapping) SetXmlSchemaQualifiedName(v string) { + o.xmlSchema.SetQualifiedName(v) +} + +// JsonStructureQualifiedName returns the value of the jsonStructure property. +func (o *ExportMapping) JsonStructureQualifiedName() string { + return o.jsonStructure.QualifiedName() +} + +// SetJsonStructureQualifiedName sets the value of the jsonStructure property. +func (o *ExportMapping) SetJsonStructureQualifiedName(v string) { + o.jsonStructure.SetQualifiedName(v) +} + +// RootElementName returns the value of the rootElementName property. +func (o *ExportMapping) RootElementName() string { + return o.rootElementName.Get() +} + +// SetRootElementName sets the value of the rootElementName property. +func (o *ExportMapping) SetRootElementName(v string) { + o.rootElementName.Set(v) +} + +// ImportedWebServiceQualifiedName returns the value of the importedWebService property. +func (o *ExportMapping) ImportedWebServiceQualifiedName() string { + return o.importedWebService.QualifiedName() +} + +// SetImportedWebServiceQualifiedName sets the value of the importedWebService property. +func (o *ExportMapping) SetImportedWebServiceQualifiedName(v string) { + o.importedWebService.SetQualifiedName(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *ExportMapping) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *ExportMapping) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// OperationName returns the value of the operationName property. +func (o *ExportMapping) OperationName() string { + return o.operationName.Get() +} + +// SetOperationName sets the value of the operationName property. +func (o *ExportMapping) SetOperationName(v string) { + o.operationName.Set(v) +} + +// MessageDefinitionQualifiedName returns the value of the messageDefinition property. +func (o *ExportMapping) MessageDefinitionQualifiedName() string { + return o.messageDefinition.QualifiedName() +} + +// SetMessageDefinitionQualifiedName sets the value of the messageDefinition property. +func (o *ExportMapping) SetMessageDefinitionQualifiedName(v string) { + o.messageDefinition.SetQualifiedName(v) +} + +// MappingSourceReference returns the value of the mappingSourceReference property. +func (o *ExportMapping) MappingSourceReference() element.Element { + return o.mappingSourceReference.Get() +} + +// SetMappingSourceReference sets the value of the mappingSourceReference property. +func (o *ExportMapping) SetMappingSourceReference(v element.Element) { + o.mappingSourceReference.Set(v) +} + +// PublicName returns the value of the publicName property. +func (o *ExportMapping) PublicName() string { + return o.publicName.Get() +} + +// SetPublicName sets the value of the publicName property. +func (o *ExportMapping) SetPublicName(v string) { + o.publicName.Set(v) +} + +// ParameterName returns the value of the parameterName property. +func (o *ExportMapping) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *ExportMapping) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// ParameterTypeName returns the value of the parameterTypeName property. +func (o *ExportMapping) ParameterTypeName() string { + return o.parameterTypeName.Get() +} + +// SetParameterTypeName sets the value of the parameterTypeName property. +func (o *ExportMapping) SetParameterTypeName(v string) { + o.parameterTypeName.Set(v) +} + +// IsHeader returns the value of the isHeader property. +func (o *ExportMapping) IsHeader() bool { + return o.isHeader.Get() +} + +// SetIsHeader sets the value of the isHeader property. +func (o *ExportMapping) SetIsHeader(v bool) { + o.isHeader.Set(v) +} + +// NullValueOption returns the value of the nullValueOption property. +func (o *ExportMapping) NullValueOption() string { + return o.nullValueOption.Get() +} + +// SetNullValueOption sets the value of the nullValueOption property. +func (o *ExportMapping) SetNullValueOption(v string) { + o.nullValueOption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExportMapping) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "RootMappingElements"); err == nil { + for _, child := range children { + o.rootMappingElements.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("XmlSchema"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.xmlSchema.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("JsonStructure"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.jsonStructure.SetFromDecode(s) + } + } + o.rootElementName.Init(raw) + if val, err := raw.LookupErr("ImportedWebService"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.importedWebService.SetFromDecode(s) + } + } + o.serviceName.Init(raw) + o.operationName.Init(raw) + if val, err := raw.LookupErr("MessageDefinition"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.messageDefinition.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "MappingSourceReference"); err == nil { + o.mappingSourceReference.SetFromDecode(child) + } + o.publicName.Init(raw) + o.parameterName.Init(raw) + o.parameterTypeName.Init(raw) + o.isHeader.Init(raw) + if val, err := raw.LookupErr("NullValueOption"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.nullValueOption.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ExportObjectMappingElement +// ──────────────────────────────────────────────────────── + +type ExportObjectMappingElement struct { + element.Base + documentation *property.Primitive[string] + elementType *property.Enum[string] + path *property.Primitive[string] + jsonPath *property.Primitive[string] + xmlPath *property.Primitive[string] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + mappingMicroflowCall *property.Part[element.Element] + children *property.PartList[element.Element] + entity *property.ByNameRef[element.Element] + association *property.ByNameRef[element.Element] + objectHandling *property.Enum[string] + objectHandlingBackup *property.Enum[string] + objectHandlingBackupAllowOverride *property.Primitive[bool] + isDefaultType *property.Primitive[bool] +} + +// Documentation returns the value of the documentation property. +func (o *ExportObjectMappingElement) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ExportObjectMappingElement) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// ElementType returns the value of the elementType property. +func (o *ExportObjectMappingElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ExportObjectMappingElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// Path returns the value of the path property. +func (o *ExportObjectMappingElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ExportObjectMappingElement) SetPath(v string) { + o.path.Set(v) +} + +// JsonPath returns the value of the jsonPath property. +func (o *ExportObjectMappingElement) JsonPath() string { + return o.jsonPath.Get() +} + +// SetJsonPath sets the value of the jsonPath property. +func (o *ExportObjectMappingElement) SetJsonPath(v string) { + o.jsonPath.Set(v) +} + +// XmlPath returns the value of the xmlPath property. +func (o *ExportObjectMappingElement) XmlPath() string { + return o.xmlPath.Get() +} + +// SetXmlPath sets the value of the xmlPath property. +func (o *ExportObjectMappingElement) SetXmlPath(v string) { + o.xmlPath.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ExportObjectMappingElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ExportObjectMappingElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ExportObjectMappingElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ExportObjectMappingElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ExportObjectMappingElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ExportObjectMappingElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ExportObjectMappingElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ExportObjectMappingElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// MappingMicroflowCall returns the value of the mappingMicroflowCall property. +func (o *ExportObjectMappingElement) MappingMicroflowCall() element.Element { + return o.mappingMicroflowCall.Get() +} + +// SetMappingMicroflowCall sets the value of the mappingMicroflowCall property. +func (o *ExportObjectMappingElement) SetMappingMicroflowCall(v element.Element) { + o.mappingMicroflowCall.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *ExportObjectMappingElement) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *ExportObjectMappingElement) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *ExportObjectMappingElement) RemoveChildren(index int) { + o.children.Remove(index) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ExportObjectMappingElement) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ExportObjectMappingElement) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *ExportObjectMappingElement) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *ExportObjectMappingElement) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// ObjectHandling returns the value of the objectHandling property. +func (o *ExportObjectMappingElement) ObjectHandling() string { + return o.objectHandling.Get() +} + +// SetObjectHandling sets the value of the objectHandling property. +func (o *ExportObjectMappingElement) SetObjectHandling(v string) { + o.objectHandling.Set(v) +} + +// ObjectHandlingBackup returns the value of the objectHandlingBackup property. +func (o *ExportObjectMappingElement) ObjectHandlingBackup() string { + return o.objectHandlingBackup.Get() +} + +// SetObjectHandlingBackup sets the value of the objectHandlingBackup property. +func (o *ExportObjectMappingElement) SetObjectHandlingBackup(v string) { + o.objectHandlingBackup.Set(v) +} + +// ObjectHandlingBackupAllowOverride returns the value of the objectHandlingBackupAllowOverride property. +func (o *ExportObjectMappingElement) ObjectHandlingBackupAllowOverride() bool { + return o.objectHandlingBackupAllowOverride.Get() +} + +// SetObjectHandlingBackupAllowOverride sets the value of the objectHandlingBackupAllowOverride property. +func (o *ExportObjectMappingElement) SetObjectHandlingBackupAllowOverride(v bool) { + o.objectHandlingBackupAllowOverride.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *ExportObjectMappingElement) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *ExportObjectMappingElement) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExportObjectMappingElement) InitFromRaw(raw bson.Raw) { + o.documentation.Init(raw) + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.jsonPath.Init(raw) + o.xmlPath.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + if child, err := codec.DecodeChild(raw, "MappingMicroflowCall"); err == nil { + o.mappingMicroflowCall.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.association.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ObjectHandling"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.objectHandling.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ObjectHandlingBackup"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.objectHandlingBackup.SetFromDecode(s) + } + } + o.objectHandlingBackupAllowOverride.Init(raw) + o.isDefaultType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ExportValueMappingElement +// ──────────────────────────────────────────────────────── + +type ExportValueMappingElement struct { + element.Base + documentation *property.Primitive[string] + elementType *property.Enum[string] + path *property.Primitive[string] + jsonPath *property.Primitive[string] + xmlPath *property.Primitive[string] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + xmlDataType *property.Primitive[string] + propType *property.Part[element.Element] + isKey *property.Primitive[bool] + isXmlAttribute *property.Primitive[bool] + xmlPrimitiveType *property.Enum[string] + isContent *property.Primitive[bool] + attribute *property.ByNameRef[element.Element] + converter *property.ByNameRef[element.Element] + expectedContentTypes *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + originalValue *property.Primitive[string] +} + +// Documentation returns the value of the documentation property. +func (o *ExportValueMappingElement) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ExportValueMappingElement) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// ElementType returns the value of the elementType property. +func (o *ExportValueMappingElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ExportValueMappingElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// Path returns the value of the path property. +func (o *ExportValueMappingElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ExportValueMappingElement) SetPath(v string) { + o.path.Set(v) +} + +// JsonPath returns the value of the jsonPath property. +func (o *ExportValueMappingElement) JsonPath() string { + return o.jsonPath.Get() +} + +// SetJsonPath sets the value of the jsonPath property. +func (o *ExportValueMappingElement) SetJsonPath(v string) { + o.jsonPath.Set(v) +} + +// XmlPath returns the value of the xmlPath property. +func (o *ExportValueMappingElement) XmlPath() string { + return o.xmlPath.Get() +} + +// SetXmlPath sets the value of the xmlPath property. +func (o *ExportValueMappingElement) SetXmlPath(v string) { + o.xmlPath.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ExportValueMappingElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ExportValueMappingElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ExportValueMappingElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ExportValueMappingElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ExportValueMappingElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ExportValueMappingElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ExportValueMappingElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ExportValueMappingElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// XmlDataType returns the value of the xmlDataType property. +func (o *ExportValueMappingElement) XmlDataType() string { + return o.xmlDataType.Get() +} + +// SetXmlDataType sets the value of the xmlDataType property. +func (o *ExportValueMappingElement) SetXmlDataType(v string) { + o.xmlDataType.Set(v) +} + +// Type returns the value of the type property. +func (o *ExportValueMappingElement) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *ExportValueMappingElement) SetType(v element.Element) { + o.propType.Set(v) +} + +// IsKey returns the value of the isKey property. +func (o *ExportValueMappingElement) IsKey() bool { + return o.isKey.Get() +} + +// SetIsKey sets the value of the isKey property. +func (o *ExportValueMappingElement) SetIsKey(v bool) { + o.isKey.Set(v) +} + +// IsXmlAttribute returns the value of the isXmlAttribute property. +func (o *ExportValueMappingElement) IsXmlAttribute() bool { + return o.isXmlAttribute.Get() +} + +// SetIsXmlAttribute sets the value of the isXmlAttribute property. +func (o *ExportValueMappingElement) SetIsXmlAttribute(v bool) { + o.isXmlAttribute.Set(v) +} + +// XmlPrimitiveType returns the value of the xmlPrimitiveType property. +func (o *ExportValueMappingElement) XmlPrimitiveType() string { + return o.xmlPrimitiveType.Get() +} + +// SetXmlPrimitiveType sets the value of the xmlPrimitiveType property. +func (o *ExportValueMappingElement) SetXmlPrimitiveType(v string) { + o.xmlPrimitiveType.Set(v) +} + +// IsContent returns the value of the isContent property. +func (o *ExportValueMappingElement) IsContent() bool { + return o.isContent.Get() +} + +// SetIsContent sets the value of the isContent property. +func (o *ExportValueMappingElement) SetIsContent(v bool) { + o.isContent.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ExportValueMappingElement) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ExportValueMappingElement) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// ConverterQualifiedName returns the value of the converter property. +func (o *ExportValueMappingElement) ConverterQualifiedName() string { + return o.converter.QualifiedName() +} + +// SetConverterQualifiedName sets the value of the converter property. +func (o *ExportValueMappingElement) SetConverterQualifiedName(v string) { + o.converter.SetQualifiedName(v) +} + +// ExpectedContentTypes returns the value of the expectedContentTypes property. +func (o *ExportValueMappingElement) ExpectedContentTypes() string { + return o.expectedContentTypes.Get() +} + +// SetExpectedContentTypes sets the value of the expectedContentTypes property. +func (o *ExportValueMappingElement) SetExpectedContentTypes(v string) { + o.expectedContentTypes.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *ExportValueMappingElement) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *ExportValueMappingElement) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *ExportValueMappingElement) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *ExportValueMappingElement) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *ExportValueMappingElement) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *ExportValueMappingElement) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// OriginalValue returns the value of the originalValue property. +func (o *ExportValueMappingElement) OriginalValue() string { + return o.originalValue.Get() +} + +// SetOriginalValue sets the value of the originalValue property. +func (o *ExportValueMappingElement) SetOriginalValue(v string) { + o.originalValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExportValueMappingElement) InitFromRaw(raw bson.Raw) { + o.documentation.Init(raw) + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.jsonPath.Init(raw) + o.xmlPath.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.xmlDataType.Init(raw) + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } + o.isKey.Init(raw) + o.isXmlAttribute.Init(raw) + if val, err := raw.LookupErr("XmlPrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.xmlPrimitiveType.SetFromDecode(s) + } + } + o.isContent.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Converter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.converter.SetFromDecode(s) + } + } + o.expectedContentTypes.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.originalValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initExportMapping creates a ExportMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExportMapping() *ExportMapping { + o := &ExportMapping{} + o.SetTypeName("ExportMappings$ExportMapping") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.rootMappingElements = property.NewPartList[element.Element]("RootMappingElements") + o.rootMappingElements.Bind(&o.Base, 4) + o.xmlSchema = property.NewByNameRef[element.Element]("XmlSchema", "XmlSchemas$XmlSchema") + o.xmlSchema.Bind(&o.Base, 5) + o.jsonStructure = property.NewByNameRef[element.Element]("JsonStructure", "JsonStructures$JsonStructure") + o.jsonStructure.Bind(&o.Base, 6) + o.rootElementName = property.NewPrimitive[string]("RootElementName", property.DecodeString) + o.rootElementName.Bind(&o.Base, 7) + o.importedWebService = property.NewByNameRef[element.Element]("ImportedWebService", "WebServices$ImportedWebService") + o.importedWebService.Bind(&o.Base, 8) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 9) + o.operationName = property.NewPrimitive[string]("OperationName", property.DecodeString) + o.operationName.Bind(&o.Base, 10) + o.messageDefinition = property.NewByNameRef[element.Element]("MessageDefinition", "MessageDefinitions$MessageDefinition") + o.messageDefinition.Bind(&o.Base, 11) + o.mappingSourceReference = property.NewPart[element.Element]("MappingSourceReference") + o.mappingSourceReference.Bind(&o.Base, 12) + o.publicName = property.NewPrimitive[string]("PublicName", property.DecodeString) + o.publicName.Bind(&o.Base, 13) + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 14) + o.parameterTypeName = property.NewPrimitive[string]("ParameterTypeName", property.DecodeString) + o.parameterTypeName.Bind(&o.Base, 15) + o.isHeader = property.NewPrimitive[bool]("IsHeader", property.DecodeBool) + o.isHeader.Bind(&o.Base, 16) + o.nullValueOption = property.NewEnum[string]("NullValueOption") + o.nullValueOption.Bind(&o.Base, 17) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.rootMappingElements, o.xmlSchema, o.jsonStructure, o.rootElementName, o.importedWebService, o.serviceName, o.operationName, o.messageDefinition, o.mappingSourceReference, o.publicName, o.parameterName, o.parameterTypeName, o.isHeader, o.nullValueOption}) + return o +} + +// NewExportMapping creates a new ExportMapping for user code. Marked dirty (bit 63 = new element). +func NewExportMapping() *ExportMapping { + o := initExportMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExportObjectMappingElement creates a ExportObjectMappingElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExportObjectMappingElement() *ExportObjectMappingElement { + o := &ExportObjectMappingElement{} + o.SetTypeName("ExportMappings$ObjectMappingElement") + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 0) + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.jsonPath = property.NewPrimitive[string]("JsonPath", property.DecodeString) + o.jsonPath.Bind(&o.Base, 3) + o.xmlPath = property.NewPrimitive[string]("XmlPath", property.DecodeString) + o.xmlPath.Bind(&o.Base, 4) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 5) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 6) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 7) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 8) + o.mappingMicroflowCall = property.NewPart[element.Element]("MappingMicroflowCall") + o.mappingMicroflowCall.Bind(&o.Base, 9) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 10) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 11) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 12) + o.objectHandling = property.NewEnum[string]("ObjectHandling") + o.objectHandling.Bind(&o.Base, 13) + o.objectHandlingBackup = property.NewEnum[string]("ObjectHandlingBackup") + o.objectHandlingBackup.Bind(&o.Base, 14) + o.objectHandlingBackupAllowOverride = property.NewPrimitive[bool]("ObjectHandlingBackupAllowOverride", property.DecodeBool) + o.objectHandlingBackupAllowOverride.Bind(&o.Base, 15) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 16) + o.SetProperties([]element.Property{o.documentation, o.elementType, o.path, o.jsonPath, o.xmlPath, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.mappingMicroflowCall, o.children, o.entity, o.association, o.objectHandling, o.objectHandlingBackup, o.objectHandlingBackupAllowOverride, o.isDefaultType}) + return o +} + +// NewExportObjectMappingElement creates a new ExportObjectMappingElement for user code. Marked dirty (bit 63 = new element). +func NewExportObjectMappingElement() *ExportObjectMappingElement { + o := initExportObjectMappingElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExportValueMappingElement creates a ExportValueMappingElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExportValueMappingElement() *ExportValueMappingElement { + o := &ExportValueMappingElement{} + o.SetTypeName("ExportMappings$ValueMappingElement") + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 0) + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.jsonPath = property.NewPrimitive[string]("JsonPath", property.DecodeString) + o.jsonPath.Bind(&o.Base, 3) + o.xmlPath = property.NewPrimitive[string]("XmlPath", property.DecodeString) + o.xmlPath.Bind(&o.Base, 4) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 5) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 6) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 7) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 8) + o.xmlDataType = property.NewPrimitive[string]("XmlDataType", property.DecodeString) + o.xmlDataType.Bind(&o.Base, 9) + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 10) + o.isKey = property.NewPrimitive[bool]("IsKey", property.DecodeBool) + o.isKey.Bind(&o.Base, 11) + o.isXmlAttribute = property.NewPrimitive[bool]("IsXmlAttribute", property.DecodeBool) + o.isXmlAttribute.Bind(&o.Base, 12) + o.xmlPrimitiveType = property.NewEnum[string]("XmlPrimitiveType") + o.xmlPrimitiveType.Bind(&o.Base, 13) + o.isContent = property.NewPrimitive[bool]("IsContent", property.DecodeBool) + o.isContent.Bind(&o.Base, 14) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 15) + o.converter = property.NewByNameRef[element.Element]("Converter", "Microflows$Microflow") + o.converter.Bind(&o.Base, 16) + o.expectedContentTypes = property.NewPrimitive[string]("ExpectedContentTypes", property.DecodeString) + o.expectedContentTypes.Bind(&o.Base, 17) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 18) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 19) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 20) + o.originalValue = property.NewPrimitive[string]("OriginalValue", property.DecodeString) + o.originalValue.Bind(&o.Base, 21) + o.SetProperties([]element.Property{o.documentation, o.elementType, o.path, o.jsonPath, o.xmlPath, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.xmlDataType, o.propType, o.isKey, o.isXmlAttribute, o.xmlPrimitiveType, o.isContent, o.attribute, o.converter, o.expectedContentTypes, o.maxLength, o.fractionDigits, o.totalDigits, o.originalValue}) + return o +} + +// NewExportValueMappingElement creates a new ExportValueMappingElement for user code. Marked dirty (bit 63 = new element). +func NewExportValueMappingElement() *ExportValueMappingElement { + o := initExportValueMappingElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("ExportMappings$ExportMapping", func() element.Element { + return initExportMapping() + }) + codec.DefaultRegistry.Register("ExportMappings$ExportObjectMappingElement", func() element.Element { + o := initExportObjectMappingElement() + o.SetTypeName("ExportMappings$ExportObjectMappingElement") + return o + }) + codec.DefaultRegistry.Register("ExportMappings$ObjectMappingElement", func() element.Element { + return initExportObjectMappingElement() + }) + codec.DefaultRegistry.Register("ExportMappings$ExportValueMappingElement", func() element.Element { + o := initExportValueMappingElement() + o.SetTypeName("ExportMappings$ExportValueMappingElement") + return o + }) + codec.DefaultRegistry.Register("ExportMappings$ValueMappingElement", func() element.Element { + return initExportValueMappingElement() + }) +} diff --git a/modelsdk/gen/exportmappings/version.go b/modelsdk/gen/exportmappings/version.go new file mode 100644 index 00000000..915e0d61 --- /dev/null +++ b/modelsdk/gen/exportmappings/version.go @@ -0,0 +1,17 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package exportmappings + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "ExportMappings$ExportMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "nullValueOption": {Introduced: "6.7.0"}, + "parameterTypeName": {Deleted: "6.1.0"}, + }, + }, +} diff --git a/modelsdk/gen/expressions/enums.go b/modelsdk/gen/expressions/enums.go new file mode 100644 index 00000000..0c7deddf --- /dev/null +++ b/modelsdk/gen/expressions/enums.go @@ -0,0 +1,34 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package expressions + +// BinaryOperator enumerates the possible values for the BinaryOperator type. +type BinaryOperator = string + +const ( + BinaryOperatorNone BinaryOperator = "None" + BinaryOperatorAnd BinaryOperator = "And" + BinaryOperatorOr BinaryOperator = "Or" + BinaryOperatorEquals BinaryOperator = "Equals" + BinaryOperatorNotEquals BinaryOperator = "NotEquals" + BinaryOperatorGreaterThan BinaryOperator = "GreaterThan" + BinaryOperatorLessThan BinaryOperator = "LessThan" + BinaryOperatorGreaterThanOrEqual BinaryOperator = "GreaterThanOrEqual" + BinaryOperatorLessThanOrEqual BinaryOperator = "LessThanOrEqual" + BinaryOperatorMinus BinaryOperator = "Minus" + BinaryOperatorPlus BinaryOperator = "Plus" + BinaryOperatorMultiply BinaryOperator = "Multiply" + BinaryOperatorDivide BinaryOperator = "Divide" + BinaryOperatorDiv BinaryOperator = "Div" + BinaryOperatorMod BinaryOperator = "Mod" +) + +// UnaryOperator enumerates the possible values for the UnaryOperator type. +type UnaryOperator = string + +const ( + UnaryOperatorNone UnaryOperator = "None" + UnaryOperatorUnaryMinus UnaryOperator = "UnaryMinus" +) diff --git a/modelsdk/gen/expressions/refs.go b/modelsdk/gen/expressions/refs.go new file mode 100644 index 00000000..d44d2e5c --- /dev/null +++ b/modelsdk/gen/expressions/refs.go @@ -0,0 +1,16 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package expressions + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Expressions$ConstantRefExpression", []codec.RefMeta{ + {Prop: "Constant", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Expressions$EnumerationValueRefExpression", []codec.RefMeta{ + {Prop: "Value", Kind: codec.RefByName, Target: "Enumerations$EnumerationValue"}, + }) +} diff --git a/modelsdk/gen/expressions/types.go b/modelsdk/gen/expressions/types.go new file mode 100644 index 00000000..75f6ab73 --- /dev/null +++ b/modelsdk/gen/expressions/types.go @@ -0,0 +1,978 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package expressions + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Expression +// ──────────────────────────────────────────────────────── + +type Expression struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Expression) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BinaryExpression +// ──────────────────────────────────────────────────────── + +type BinaryExpression struct { + element.Base + operator *property.Enum[string] + left *property.Part[element.Element] + right *property.Part[element.Element] +} + +// Operator returns the value of the operator property. +func (o *BinaryExpression) Operator() string { + return o.operator.Get() +} + +// SetOperator sets the value of the operator property. +func (o *BinaryExpression) SetOperator(v string) { + o.operator.Set(v) +} + +// Left returns the value of the left property. +func (o *BinaryExpression) Left() element.Element { + return o.left.Get() +} + +// SetLeft sets the value of the left property. +func (o *BinaryExpression) SetLeft(v element.Element) { + o.left.Set(v) +} + +// Right returns the value of the right property. +func (o *BinaryExpression) Right() element.Element { + return o.right.Get() +} + +// SetRight sets the value of the right property. +func (o *BinaryExpression) SetRight(v element.Element) { + o.right.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BinaryExpression) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Operator"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.operator.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Left"); err == nil { + o.left.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Right"); err == nil { + o.right.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// LiteralExpression +// ──────────────────────────────────────────────────────── + +type LiteralExpression struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LiteralExpression) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BooleanLiteral +// ──────────────────────────────────────────────────────── + +type BooleanLiteral struct { + element.Base + value *property.Primitive[bool] +} + +// Value returns the value of the value property. +func (o *BooleanLiteral) Value() bool { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *BooleanLiteral) SetValue(v bool) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BooleanLiteral) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConstantRefExpression +// ──────────────────────────────────────────────────────── + +type ConstantRefExpression struct { + element.Base + constant *property.ByNameRef[element.Element] +} + +// ConstantQualifiedName returns the value of the constant property. +func (o *ConstantRefExpression) ConstantQualifiedName() string { + return o.constant.QualifiedName() +} + +// SetConstantQualifiedName sets the value of the constant property. +func (o *ConstantRefExpression) SetConstantQualifiedName(v string) { + o.constant.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConstantRefExpression) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Constant"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.constant.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// EmptyLiteral +// ──────────────────────────────────────────────────────── + +type EmptyLiteral struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EmptyLiteral) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EnumerationValueRefExpression +// ──────────────────────────────────────────────────────── + +type EnumerationValueRefExpression struct { + element.Base + value *property.ByNameRef[element.Element] +} + +// ValueQualifiedName returns the value of the value property. +func (o *EnumerationValueRefExpression) ValueQualifiedName() string { + return o.value.QualifiedName() +} + +// SetValueQualifiedName sets the value of the value property. +func (o *EnumerationValueRefExpression) SetValueQualifiedName(v string) { + o.value.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EnumerationValueRefExpression) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Value"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.value.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// FloatLiteral +// ──────────────────────────────────────────────────────── + +type FloatLiteral struct { + element.Base + value *property.Primitive[float64] +} + +// Value returns the value of the value property. +func (o *FloatLiteral) Value() float64 { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *FloatLiteral) SetValue(v float64) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FloatLiteral) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// FunctionCallExpression +// ──────────────────────────────────────────────────────── + +type FunctionCallExpression struct { + element.Base + functionName *property.Primitive[string] + arguments *property.PartList[element.Element] +} + +// FunctionName returns the value of the functionName property. +func (o *FunctionCallExpression) FunctionName() string { + return o.functionName.Get() +} + +// SetFunctionName sets the value of the functionName property. +func (o *FunctionCallExpression) SetFunctionName(v string) { + o.functionName.Set(v) +} + +// ArgumentsItems returns the value of the arguments property. +func (o *FunctionCallExpression) ArgumentsItems() []element.Element { + return o.arguments.Items() +} + +// AddArguments appends a child element to the arguments list. +func (o *FunctionCallExpression) AddArguments(v element.Element) { + o.arguments.Append(v) +} + +// RemoveArguments removes the element at the given index from the arguments list. +func (o *FunctionCallExpression) RemoveArguments(index int) { + o.arguments.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FunctionCallExpression) InitFromRaw(raw bson.Raw) { + o.functionName.Init(raw) + if children, err := codec.DecodeChildren(raw, "Arguments"); err == nil { + for _, child := range children { + o.arguments.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// VariableRef +// ──────────────────────────────────────────────────────── + +type VariableRef struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VariableRef) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// GlobalVariableRef +// ──────────────────────────────────────────────────────── + +type GlobalVariableRef struct { + element.Base + referredName *property.Primitive[string] +} + +// ReferredName returns the value of the referredName property. +func (o *GlobalVariableRef) ReferredName() string { + return o.referredName.Get() +} + +// SetReferredName sets the value of the referredName property. +func (o *GlobalVariableRef) SetReferredName(v string) { + o.referredName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GlobalVariableRef) InitFromRaw(raw bson.Raw) { + o.referredName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// IfExpression +// ──────────────────────────────────────────────────────── + +type IfExpression struct { + element.Base + condition *property.Part[element.Element] + ifTrue *property.Part[element.Element] + ifFalse *property.Part[element.Element] +} + +// Condition returns the value of the condition property. +func (o *IfExpression) Condition() element.Element { + return o.condition.Get() +} + +// SetCondition sets the value of the condition property. +func (o *IfExpression) SetCondition(v element.Element) { + o.condition.Set(v) +} + +// IfTrue returns the value of the ifTrue property. +func (o *IfExpression) IfTrue() element.Element { + return o.ifTrue.Get() +} + +// SetIfTrue sets the value of the ifTrue property. +func (o *IfExpression) SetIfTrue(v element.Element) { + o.ifTrue.Set(v) +} + +// IfFalse returns the value of the ifFalse property. +func (o *IfExpression) IfFalse() element.Element { + return o.ifFalse.Get() +} + +// SetIfFalse sets the value of the ifFalse property. +func (o *IfExpression) SetIfFalse(v element.Element) { + o.ifFalse.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IfExpression) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Condition"); err == nil { + o.condition.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "IfTrue"); err == nil { + o.ifTrue.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "IfFalse"); err == nil { + o.ifFalse.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// IntegerLiteral +// ──────────────────────────────────────────────────────── + +type IntegerLiteral struct { + element.Base + value *property.Primitive[int32] +} + +// Value returns the value of the value property. +func (o *IntegerLiteral) Value() int32 { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *IntegerLiteral) SetValue(v int32) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IntegerLiteral) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// NoExpression +// ──────────────────────────────────────────────────────── + +type NoExpression struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NoExpression) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// NoVariableRef +// ──────────────────────────────────────────────────────── + +type NoVariableRef struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NoVariableRef) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ParenthesisExpression +// ──────────────────────────────────────────────────────── + +type ParenthesisExpression struct { + element.Base + expression *property.Part[element.Element] +} + +// Expression returns the value of the expression property. +func (o *ParenthesisExpression) Expression() element.Element { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *ParenthesisExpression) SetExpression(v element.Element) { + o.expression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ParenthesisExpression) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Expression"); err == nil { + o.expression.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// StringLiteral +// ──────────────────────────────────────────────────────── + +type StringLiteral struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *StringLiteral) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *StringLiteral) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringLiteral) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// UnaryExpression +// ──────────────────────────────────────────────────────── + +type UnaryExpression struct { + element.Base + operator *property.Enum[string] + expression *property.Part[element.Element] +} + +// Operator returns the value of the operator property. +func (o *UnaryExpression) Operator() string { + return o.operator.Get() +} + +// SetOperator sets the value of the operator property. +func (o *UnaryExpression) SetOperator(v string) { + o.operator.Set(v) +} + +// Expression returns the value of the expression property. +func (o *UnaryExpression) Expression() element.Element { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *UnaryExpression) SetExpression(v element.Element) { + o.expression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UnaryExpression) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Operator"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.operator.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Expression"); err == nil { + o.expression.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// UnparsableExpression +// ──────────────────────────────────────────────────────── + +type UnparsableExpression struct { + element.Base + expression *property.Primitive[string] +} + +// Expression returns the value of the expression property. +func (o *UnparsableExpression) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *UnparsableExpression) SetExpression(v string) { + o.expression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UnparsableExpression) InitFromRaw(raw bson.Raw) { + o.expression.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// VariableRefExpression +// ──────────────────────────────────────────────────────── + +type VariableRefExpression struct { + element.Base + variable *property.Part[element.Element] + member *property.Part[element.Element] +} + +// Variable returns the value of the variable property. +func (o *VariableRefExpression) Variable() element.Element { + return o.variable.Get() +} + +// SetVariable sets the value of the variable property. +func (o *VariableRefExpression) SetVariable(v element.Element) { + o.variable.Set(v) +} + +// Member returns the value of the member property. +func (o *VariableRefExpression) Member() element.Element { + return o.member.Get() +} + +// SetMember sets the value of the member property. +func (o *VariableRefExpression) SetMember(v element.Element) { + o.member.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VariableRefExpression) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Variable"); err == nil { + o.variable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Member"); err == nil { + o.member.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initBinaryExpression creates a BinaryExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBinaryExpression() *BinaryExpression { + o := &BinaryExpression{} + o.SetTypeName("Expressions$BinaryExpression") + o.operator = property.NewEnum[string]("Operator") + o.operator.Bind(&o.Base, 0) + o.left = property.NewPart[element.Element]("Left") + o.left.Bind(&o.Base, 1) + o.right = property.NewPart[element.Element]("Right") + o.right.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.operator, o.left, o.right}) + return o +} + +// NewBinaryExpression creates a new BinaryExpression for user code. Marked dirty (bit 63 = new element). +func NewBinaryExpression() *BinaryExpression { + o := initBinaryExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBooleanLiteral creates a BooleanLiteral with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBooleanLiteral() *BooleanLiteral { + o := &BooleanLiteral{} + o.SetTypeName("Expressions$BooleanLiteral") + o.value = property.NewPrimitive[bool]("Value", property.DecodeBool) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value}) + return o +} + +// NewBooleanLiteral creates a new BooleanLiteral for user code. Marked dirty (bit 63 = new element). +func NewBooleanLiteral() *BooleanLiteral { + o := initBooleanLiteral() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConstantRefExpression creates a ConstantRefExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConstantRefExpression() *ConstantRefExpression { + o := &ConstantRefExpression{} + o.SetTypeName("Expressions$ConstantRefExpression") + o.constant = property.NewByNameRef[element.Element]("Constant", "Constants$Constant") + o.constant.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.constant}) + return o +} + +// NewConstantRefExpression creates a new ConstantRefExpression for user code. Marked dirty (bit 63 = new element). +func NewConstantRefExpression() *ConstantRefExpression { + o := initConstantRefExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEmptyLiteral creates a EmptyLiteral with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEmptyLiteral() *EmptyLiteral { + o := &EmptyLiteral{} + o.SetTypeName("Expressions$EmptyLiteral") + o.SetProperties([]element.Property{}) + return o +} + +// NewEmptyLiteral creates a new EmptyLiteral for user code. Marked dirty (bit 63 = new element). +func NewEmptyLiteral() *EmptyLiteral { + o := initEmptyLiteral() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEnumerationValueRefExpression creates a EnumerationValueRefExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEnumerationValueRefExpression() *EnumerationValueRefExpression { + o := &EnumerationValueRefExpression{} + o.SetTypeName("Expressions$EnumerationValueRefExpression") + o.value = property.NewByNameRef[element.Element]("Value", "Enumerations$EnumerationValue") + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value}) + return o +} + +// NewEnumerationValueRefExpression creates a new EnumerationValueRefExpression for user code. Marked dirty (bit 63 = new element). +func NewEnumerationValueRefExpression() *EnumerationValueRefExpression { + o := initEnumerationValueRefExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFloatLiteral creates a FloatLiteral with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFloatLiteral() *FloatLiteral { + o := &FloatLiteral{} + o.SetTypeName("Expressions$FloatLiteral") + o.value = property.NewPrimitive[float64]("Value", property.DecodeFloat64) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value}) + return o +} + +// NewFloatLiteral creates a new FloatLiteral for user code. Marked dirty (bit 63 = new element). +func NewFloatLiteral() *FloatLiteral { + o := initFloatLiteral() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFunctionCallExpression creates a FunctionCallExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFunctionCallExpression() *FunctionCallExpression { + o := &FunctionCallExpression{} + o.SetTypeName("Expressions$FunctionCallExpression") + o.functionName = property.NewPrimitive[string]("FunctionName", property.DecodeString) + o.functionName.Bind(&o.Base, 0) + o.arguments = property.NewPartList[element.Element]("Arguments") + o.arguments.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.functionName, o.arguments}) + return o +} + +// NewFunctionCallExpression creates a new FunctionCallExpression for user code. Marked dirty (bit 63 = new element). +func NewFunctionCallExpression() *FunctionCallExpression { + o := initFunctionCallExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGlobalVariableRef creates a GlobalVariableRef with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGlobalVariableRef() *GlobalVariableRef { + o := &GlobalVariableRef{} + o.SetTypeName("Expressions$GlobalVariableRef") + o.referredName = property.NewPrimitive[string]("ReferredName", property.DecodeString) + o.referredName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.referredName}) + return o +} + +// NewGlobalVariableRef creates a new GlobalVariableRef for user code. Marked dirty (bit 63 = new element). +func NewGlobalVariableRef() *GlobalVariableRef { + o := initGlobalVariableRef() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIfExpression creates a IfExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIfExpression() *IfExpression { + o := &IfExpression{} + o.SetTypeName("Expressions$IfExpression") + o.condition = property.NewPart[element.Element]("Condition") + o.condition.Bind(&o.Base, 0) + o.ifTrue = property.NewPart[element.Element]("IfTrue") + o.ifTrue.Bind(&o.Base, 1) + o.ifFalse = property.NewPart[element.Element]("IfFalse") + o.ifFalse.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.condition, o.ifTrue, o.ifFalse}) + return o +} + +// NewIfExpression creates a new IfExpression for user code. Marked dirty (bit 63 = new element). +func NewIfExpression() *IfExpression { + o := initIfExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIntegerLiteral creates a IntegerLiteral with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIntegerLiteral() *IntegerLiteral { + o := &IntegerLiteral{} + o.SetTypeName("Expressions$IntegerLiteral") + o.value = property.NewPrimitive[int32]("Value", property.DecodeInt32) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value}) + return o +} + +// NewIntegerLiteral creates a new IntegerLiteral for user code. Marked dirty (bit 63 = new element). +func NewIntegerLiteral() *IntegerLiteral { + o := initIntegerLiteral() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNoExpression creates a NoExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNoExpression() *NoExpression { + o := &NoExpression{} + o.SetTypeName("Expressions$NoExpression") + o.SetProperties([]element.Property{}) + return o +} + +// NewNoExpression creates a new NoExpression for user code. Marked dirty (bit 63 = new element). +func NewNoExpression() *NoExpression { + o := initNoExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNoVariableRef creates a NoVariableRef with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNoVariableRef() *NoVariableRef { + o := &NoVariableRef{} + o.SetTypeName("Expressions$NoVariableRef") + o.SetProperties([]element.Property{}) + return o +} + +// NewNoVariableRef creates a new NoVariableRef for user code. Marked dirty (bit 63 = new element). +func NewNoVariableRef() *NoVariableRef { + o := initNoVariableRef() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initParenthesisExpression creates a ParenthesisExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initParenthesisExpression() *ParenthesisExpression { + o := &ParenthesisExpression{} + o.SetTypeName("Expressions$ParenthesisExpression") + o.expression = property.NewPart[element.Element]("Expression") + o.expression.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.expression}) + return o +} + +// NewParenthesisExpression creates a new ParenthesisExpression for user code. Marked dirty (bit 63 = new element). +func NewParenthesisExpression() *ParenthesisExpression { + o := initParenthesisExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringLiteral creates a StringLiteral with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringLiteral() *StringLiteral { + o := &StringLiteral{} + o.SetTypeName("Expressions$StringLiteral") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value}) + return o +} + +// NewStringLiteral creates a new StringLiteral for user code. Marked dirty (bit 63 = new element). +func NewStringLiteral() *StringLiteral { + o := initStringLiteral() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUnaryExpression creates a UnaryExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUnaryExpression() *UnaryExpression { + o := &UnaryExpression{} + o.SetTypeName("Expressions$UnaryExpression") + o.operator = property.NewEnum[string]("Operator") + o.operator.Bind(&o.Base, 0) + o.expression = property.NewPart[element.Element]("Expression") + o.expression.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.operator, o.expression}) + return o +} + +// NewUnaryExpression creates a new UnaryExpression for user code. Marked dirty (bit 63 = new element). +func NewUnaryExpression() *UnaryExpression { + o := initUnaryExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUnparsableExpression creates a UnparsableExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUnparsableExpression() *UnparsableExpression { + o := &UnparsableExpression{} + o.SetTypeName("Expressions$UnparsableExpression") + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.expression}) + return o +} + +// NewUnparsableExpression creates a new UnparsableExpression for user code. Marked dirty (bit 63 = new element). +func NewUnparsableExpression() *UnparsableExpression { + o := initUnparsableExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initVariableRefExpression creates a VariableRefExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initVariableRefExpression() *VariableRefExpression { + o := &VariableRefExpression{} + o.SetTypeName("Expressions$VariableRefExpression") + o.variable = property.NewPart[element.Element]("Variable") + o.variable.Bind(&o.Base, 0) + o.member = property.NewPart[element.Element]("Member") + o.member.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.variable, o.member}) + return o +} + +// NewVariableRefExpression creates a new VariableRefExpression for user code. Marked dirty (bit 63 = new element). +func NewVariableRefExpression() *VariableRefExpression { + o := initVariableRefExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Expressions$BinaryExpression", func() element.Element { + return initBinaryExpression() + }) + codec.DefaultRegistry.Register("Expressions$BooleanLiteral", func() element.Element { + return initBooleanLiteral() + }) + codec.DefaultRegistry.Register("Expressions$ConstantRefExpression", func() element.Element { + return initConstantRefExpression() + }) + codec.DefaultRegistry.Register("Expressions$EmptyLiteral", func() element.Element { + return initEmptyLiteral() + }) + codec.DefaultRegistry.Register("Expressions$EnumerationValueRefExpression", func() element.Element { + return initEnumerationValueRefExpression() + }) + codec.DefaultRegistry.Register("Expressions$FloatLiteral", func() element.Element { + return initFloatLiteral() + }) + codec.DefaultRegistry.Register("Expressions$FunctionCallExpression", func() element.Element { + return initFunctionCallExpression() + }) + codec.DefaultRegistry.Register("Expressions$GlobalVariableRef", func() element.Element { + return initGlobalVariableRef() + }) + codec.DefaultRegistry.Register("Expressions$IfExpression", func() element.Element { + return initIfExpression() + }) + codec.DefaultRegistry.Register("Expressions$IntegerLiteral", func() element.Element { + return initIntegerLiteral() + }) + codec.DefaultRegistry.Register("Expressions$NoExpression", func() element.Element { + return initNoExpression() + }) + codec.DefaultRegistry.Register("Expressions$NoVariableRef", func() element.Element { + return initNoVariableRef() + }) + codec.DefaultRegistry.Register("Expressions$ParenthesisExpression", func() element.Element { + return initParenthesisExpression() + }) + codec.DefaultRegistry.Register("Expressions$StringLiteral", func() element.Element { + return initStringLiteral() + }) + codec.DefaultRegistry.Register("Expressions$UnaryExpression", func() element.Element { + return initUnaryExpression() + }) + codec.DefaultRegistry.Register("Expressions$UnparsableExpression", func() element.Element { + return initUnparsableExpression() + }) + codec.DefaultRegistry.Register("Expressions$VariableRefExpression", func() element.Element { + return initVariableRefExpression() + }) +} diff --git a/modelsdk/gen/expressions/version.go b/modelsdk/gen/expressions/version.go new file mode 100644 index 00000000..585d111b --- /dev/null +++ b/modelsdk/gen/expressions/version.go @@ -0,0 +1,50 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package expressions + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Expressions$BinaryExpression": { + Properties: map[string]version.PropertyVersionInfo{ + "left": {Required: true}, + "right": {Required: true}, + }, + }, + "Expressions$ConstantRefExpression": { + Properties: map[string]version.PropertyVersionInfo{ + "constant": {Required: true}, + }, + }, + "Expressions$EnumerationValueRefExpression": { + Properties: map[string]version.PropertyVersionInfo{ + "value": {Required: true}, + }, + }, + "Expressions$IfExpression": { + Properties: map[string]version.PropertyVersionInfo{ + "condition": {Required: true}, + "ifFalse": {Required: true}, + "ifTrue": {Required: true}, + }, + }, + "Expressions$ParenthesisExpression": { + Properties: map[string]version.PropertyVersionInfo{ + "expression": {Required: true}, + }, + }, + "Expressions$UnaryExpression": { + Properties: map[string]version.PropertyVersionInfo{ + "expression": {Required: true}, + }, + }, + "Expressions$VariableRefExpression": { + Properties: map[string]version.PropertyVersionInfo{ + "member": {Introduced: "7.11.0"}, + "variable": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/images/enums.go b/modelsdk/gen/images/enums.go new file mode 100644 index 00000000..6d5fcb79 --- /dev/null +++ b/modelsdk/gen/images/enums.go @@ -0,0 +1,18 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package images + +// MxImageFormat enumerates the possible values for the MxImageFormat type. +type MxImageFormat = string + +const ( + MxImageFormatUnknown MxImageFormat = "Unknown" + MxImageFormatPng MxImageFormat = "Png" + MxImageFormatJpg MxImageFormat = "Jpg" + MxImageFormatBmp MxImageFormat = "Bmp" + MxImageFormatGif MxImageFormat = "Gif" + MxImageFormatSvg MxImageFormat = "Svg" + MxImageFormatWebp MxImageFormat = "Webp" +) diff --git a/modelsdk/gen/images/refs.go b/modelsdk/gen/images/refs.go new file mode 100644 index 00000000..5f74b629 --- /dev/null +++ b/modelsdk/gen/images/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package images diff --git a/modelsdk/gen/images/types.go b/modelsdk/gen/images/types.go new file mode 100644 index 00000000..4907f74b --- /dev/null +++ b/modelsdk/gen/images/types.go @@ -0,0 +1,224 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package images + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Image +// ──────────────────────────────────────────────────────── + +type Image struct { + element.Base + name *property.Primitive[string] + imageData *property.Primitive[string] + imageFormat *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *Image) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Image) SetName(v string) { + o.name.Set(v) +} + +// ImageData returns the value of the imageData property. +func (o *Image) ImageData() string { + return o.imageData.Get() +} + +// SetImageData sets the value of the imageData property. +func (o *Image) SetImageData(v string) { + o.imageData.Set(v) +} + +// ImageFormat returns the value of the imageFormat property. +func (o *Image) ImageFormat() string { + return o.imageFormat.Get() +} + +// SetImageFormat sets the value of the imageFormat property. +func (o *Image) SetImageFormat(v string) { + o.imageFormat.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Image) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.imageData.Init(raw) + if val, err := raw.LookupErr("ImageFormat"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.imageFormat.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ImageCollection +// ──────────────────────────────────────────────────────── + +type ImageCollection struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + images *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *ImageCollection) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ImageCollection) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ImageCollection) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ImageCollection) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ImageCollection) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ImageCollection) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ImageCollection) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ImageCollection) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ImagesItems returns the value of the images property. +func (o *ImageCollection) ImagesItems() []element.Element { + return o.images.Items() +} + +// AddImages appends a child element to the images list. +func (o *ImageCollection) AddImages(v element.Element) { + o.images.Append(v) +} + +// RemoveImages removes the element at the given index from the images list. +func (o *ImageCollection) RemoveImages(index int) { + o.images.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImageCollection) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Images"); err == nil { + for _, child := range children { + o.images.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initImage creates a Image with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImage() *Image { + o := &Image{} + o.SetTypeName("Images$Image") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.imageData = property.NewPrimitive[string]("ImageData", property.DecodeString) + o.imageData.Bind(&o.Base, 1) + o.imageFormat = property.NewEnum[string]("ImageFormat") + o.imageFormat.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.imageData, o.imageFormat}) + return o +} + +// NewImage creates a new Image for user code. Marked dirty (bit 63 = new element). +func NewImage() *Image { + o := initImage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImageCollection creates a ImageCollection with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImageCollection() *ImageCollection { + o := &ImageCollection{} + o.SetTypeName("Images$ImageCollection") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.images = property.NewPartList[element.Element]("Images") + o.images.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.images}) + return o +} + +// NewImageCollection creates a new ImageCollection for user code. Marked dirty (bit 63 = new element). +func NewImageCollection() *ImageCollection { + o := initImageCollection() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Images$Image", func() element.Element { + return initImage() + }) + codec.DefaultRegistry.Register("Images$ImageCollection", func() element.Element { + return initImageCollection() + }) +} diff --git a/modelsdk/gen/images/version.go b/modelsdk/gen/images/version.go new file mode 100644 index 00000000..c3362007 --- /dev/null +++ b/modelsdk/gen/images/version.go @@ -0,0 +1,22 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package images + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Images$Image": { + Properties: map[string]version.PropertyVersionInfo{ + "imageFormat": {Introduced: "9.17.0"}, + "name": {Public: true}, + }, + }, + "Images$ImageCollection": { + Properties: map[string]version.PropertyVersionInfo{ + "images": {Public: true}, + }, + }, +} diff --git a/modelsdk/gen/importmappings/enums.go b/modelsdk/gen/importmappings/enums.go new file mode 100644 index 00000000..16de288c --- /dev/null +++ b/modelsdk/gen/importmappings/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package importmappings diff --git a/modelsdk/gen/importmappings/refs.go b/modelsdk/gen/importmappings/refs.go new file mode 100644 index 00000000..7fd70118 --- /dev/null +++ b/modelsdk/gen/importmappings/refs.go @@ -0,0 +1,33 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package importmappings + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("ImportMappings$ImportMapping", []codec.RefMeta{ + {Prop: "XmlSchema", Kind: codec.RefByName, Target: "XmlSchemas$XmlSchema"}, + {Prop: "JsonStructure", Kind: codec.RefByName, Target: "JsonStructures$JsonStructure"}, + {Prop: "ImportedWebService", Kind: codec.RefByName, Target: "WebServices$ImportedWebService"}, + {Prop: "MessageDefinition", Kind: codec.RefByName, Target: "MessageDefinitions$MessageDefinition"}, + {Prop: "Parameter", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ImportMappings$ImportObjectMappingElement", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ImportMappings$ObjectMappingElement", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ImportMappings$ImportValueMappingElement", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Converter", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ImportMappings$ValueMappingElement", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Converter", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) +} diff --git a/modelsdk/gen/importmappings/types.go b/modelsdk/gen/importmappings/types.go new file mode 100644 index 00000000..23763ca4 --- /dev/null +++ b/modelsdk/gen/importmappings/types.go @@ -0,0 +1,1009 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package importmappings + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// ImportMapping +// ──────────────────────────────────────────────────────── + +type ImportMapping struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + rootMappingElements *property.PartList[element.Element] + xmlSchema *property.ByNameRef[element.Element] + jsonStructure *property.ByNameRef[element.Element] + rootElementName *property.Primitive[string] + importedWebService *property.ByNameRef[element.Element] + serviceName *property.Primitive[string] + operationName *property.Primitive[string] + messageDefinition *property.ByNameRef[element.Element] + mappingSourceReference *property.Part[element.Element] + publicName *property.Primitive[string] + parameterType *property.Part[element.Element] + useSubtransactionsForMicroflows *property.Primitive[bool] + parameter *property.ByNameRef[element.Element] +} + +// Name returns the value of the name property. +func (o *ImportMapping) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ImportMapping) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ImportMapping) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ImportMapping) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ImportMapping) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ImportMapping) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ImportMapping) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ImportMapping) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// RootMappingElementsItems returns the value of the rootMappingElements property. +func (o *ImportMapping) RootMappingElementsItems() []element.Element { + return o.rootMappingElements.Items() +} + +// AddRootMappingElements appends a child element to the rootMappingElements list. +func (o *ImportMapping) AddRootMappingElements(v element.Element) { + o.rootMappingElements.Append(v) +} + +// RemoveRootMappingElements removes the element at the given index from the rootMappingElements list. +func (o *ImportMapping) RemoveRootMappingElements(index int) { + o.rootMappingElements.Remove(index) +} + +// XmlSchemaQualifiedName returns the value of the xmlSchema property. +func (o *ImportMapping) XmlSchemaQualifiedName() string { + return o.xmlSchema.QualifiedName() +} + +// SetXmlSchemaQualifiedName sets the value of the xmlSchema property. +func (o *ImportMapping) SetXmlSchemaQualifiedName(v string) { + o.xmlSchema.SetQualifiedName(v) +} + +// JsonStructureQualifiedName returns the value of the jsonStructure property. +func (o *ImportMapping) JsonStructureQualifiedName() string { + return o.jsonStructure.QualifiedName() +} + +// SetJsonStructureQualifiedName sets the value of the jsonStructure property. +func (o *ImportMapping) SetJsonStructureQualifiedName(v string) { + o.jsonStructure.SetQualifiedName(v) +} + +// RootElementName returns the value of the rootElementName property. +func (o *ImportMapping) RootElementName() string { + return o.rootElementName.Get() +} + +// SetRootElementName sets the value of the rootElementName property. +func (o *ImportMapping) SetRootElementName(v string) { + o.rootElementName.Set(v) +} + +// ImportedWebServiceQualifiedName returns the value of the importedWebService property. +func (o *ImportMapping) ImportedWebServiceQualifiedName() string { + return o.importedWebService.QualifiedName() +} + +// SetImportedWebServiceQualifiedName sets the value of the importedWebService property. +func (o *ImportMapping) SetImportedWebServiceQualifiedName(v string) { + o.importedWebService.SetQualifiedName(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *ImportMapping) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *ImportMapping) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// OperationName returns the value of the operationName property. +func (o *ImportMapping) OperationName() string { + return o.operationName.Get() +} + +// SetOperationName sets the value of the operationName property. +func (o *ImportMapping) SetOperationName(v string) { + o.operationName.Set(v) +} + +// MessageDefinitionQualifiedName returns the value of the messageDefinition property. +func (o *ImportMapping) MessageDefinitionQualifiedName() string { + return o.messageDefinition.QualifiedName() +} + +// SetMessageDefinitionQualifiedName sets the value of the messageDefinition property. +func (o *ImportMapping) SetMessageDefinitionQualifiedName(v string) { + o.messageDefinition.SetQualifiedName(v) +} + +// MappingSourceReference returns the value of the mappingSourceReference property. +func (o *ImportMapping) MappingSourceReference() element.Element { + return o.mappingSourceReference.Get() +} + +// SetMappingSourceReference sets the value of the mappingSourceReference property. +func (o *ImportMapping) SetMappingSourceReference(v element.Element) { + o.mappingSourceReference.Set(v) +} + +// PublicName returns the value of the publicName property. +func (o *ImportMapping) PublicName() string { + return o.publicName.Get() +} + +// SetPublicName sets the value of the publicName property. +func (o *ImportMapping) SetPublicName(v string) { + o.publicName.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *ImportMapping) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *ImportMapping) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// UseSubtransactionsForMicroflows returns the value of the useSubtransactionsForMicroflows property. +func (o *ImportMapping) UseSubtransactionsForMicroflows() bool { + return o.useSubtransactionsForMicroflows.Get() +} + +// SetUseSubtransactionsForMicroflows sets the value of the useSubtransactionsForMicroflows property. +func (o *ImportMapping) SetUseSubtransactionsForMicroflows(v bool) { + o.useSubtransactionsForMicroflows.Set(v) +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *ImportMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *ImportMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportMapping) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "RootMappingElements"); err == nil { + for _, child := range children { + o.rootMappingElements.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("XmlSchema"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.xmlSchema.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("JsonStructure"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.jsonStructure.SetFromDecode(s) + } + } + o.rootElementName.Init(raw) + if val, err := raw.LookupErr("ImportedWebService"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.importedWebService.SetFromDecode(s) + } + } + o.serviceName.Init(raw) + o.operationName.Init(raw) + if val, err := raw.LookupErr("MessageDefinition"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.messageDefinition.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "MappingSourceReference"); err == nil { + o.mappingSourceReference.SetFromDecode(child) + } + o.publicName.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } + o.useSubtransactionsForMicroflows.Init(raw) + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parameter.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ImportObjectMappingElement +// ──────────────────────────────────────────────────────── + +type ImportObjectMappingElement struct { + element.Base + documentation *property.Primitive[string] + elementType *property.Enum[string] + path *property.Primitive[string] + jsonPath *property.Primitive[string] + xmlPath *property.Primitive[string] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + mappingMicroflowCall *property.Part[element.Element] + children *property.PartList[element.Element] + entity *property.ByNameRef[element.Element] + association *property.ByNameRef[element.Element] + objectHandling *property.Enum[string] + objectHandlingBackup *property.Enum[string] + objectHandlingBackupAllowOverride *property.Primitive[bool] + isDefaultType *property.Primitive[bool] +} + +// Documentation returns the value of the documentation property. +func (o *ImportObjectMappingElement) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ImportObjectMappingElement) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// ElementType returns the value of the elementType property. +func (o *ImportObjectMappingElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ImportObjectMappingElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// Path returns the value of the path property. +func (o *ImportObjectMappingElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ImportObjectMappingElement) SetPath(v string) { + o.path.Set(v) +} + +// JsonPath returns the value of the jsonPath property. +func (o *ImportObjectMappingElement) JsonPath() string { + return o.jsonPath.Get() +} + +// SetJsonPath sets the value of the jsonPath property. +func (o *ImportObjectMappingElement) SetJsonPath(v string) { + o.jsonPath.Set(v) +} + +// XmlPath returns the value of the xmlPath property. +func (o *ImportObjectMappingElement) XmlPath() string { + return o.xmlPath.Get() +} + +// SetXmlPath sets the value of the xmlPath property. +func (o *ImportObjectMappingElement) SetXmlPath(v string) { + o.xmlPath.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ImportObjectMappingElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ImportObjectMappingElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ImportObjectMappingElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ImportObjectMappingElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ImportObjectMappingElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ImportObjectMappingElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ImportObjectMappingElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ImportObjectMappingElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// MappingMicroflowCall returns the value of the mappingMicroflowCall property. +func (o *ImportObjectMappingElement) MappingMicroflowCall() element.Element { + return o.mappingMicroflowCall.Get() +} + +// SetMappingMicroflowCall sets the value of the mappingMicroflowCall property. +func (o *ImportObjectMappingElement) SetMappingMicroflowCall(v element.Element) { + o.mappingMicroflowCall.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *ImportObjectMappingElement) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *ImportObjectMappingElement) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *ImportObjectMappingElement) RemoveChildren(index int) { + o.children.Remove(index) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ImportObjectMappingElement) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ImportObjectMappingElement) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *ImportObjectMappingElement) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *ImportObjectMappingElement) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// ObjectHandling returns the value of the objectHandling property. +func (o *ImportObjectMappingElement) ObjectHandling() string { + return o.objectHandling.Get() +} + +// SetObjectHandling sets the value of the objectHandling property. +func (o *ImportObjectMappingElement) SetObjectHandling(v string) { + o.objectHandling.Set(v) +} + +// ObjectHandlingBackup returns the value of the objectHandlingBackup property. +func (o *ImportObjectMappingElement) ObjectHandlingBackup() string { + return o.objectHandlingBackup.Get() +} + +// SetObjectHandlingBackup sets the value of the objectHandlingBackup property. +func (o *ImportObjectMappingElement) SetObjectHandlingBackup(v string) { + o.objectHandlingBackup.Set(v) +} + +// ObjectHandlingBackupAllowOverride returns the value of the objectHandlingBackupAllowOverride property. +func (o *ImportObjectMappingElement) ObjectHandlingBackupAllowOverride() bool { + return o.objectHandlingBackupAllowOverride.Get() +} + +// SetObjectHandlingBackupAllowOverride sets the value of the objectHandlingBackupAllowOverride property. +func (o *ImportObjectMappingElement) SetObjectHandlingBackupAllowOverride(v bool) { + o.objectHandlingBackupAllowOverride.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *ImportObjectMappingElement) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *ImportObjectMappingElement) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportObjectMappingElement) InitFromRaw(raw bson.Raw) { + o.documentation.Init(raw) + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.jsonPath.Init(raw) + o.xmlPath.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + if child, err := codec.DecodeChild(raw, "MappingMicroflowCall"); err == nil { + o.mappingMicroflowCall.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.association.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ObjectHandling"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.objectHandling.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ObjectHandlingBackup"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.objectHandlingBackup.SetFromDecode(s) + } + } + o.objectHandlingBackupAllowOverride.Init(raw) + o.isDefaultType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ImportValueMappingElement +// ──────────────────────────────────────────────────────── + +type ImportValueMappingElement struct { + element.Base + documentation *property.Primitive[string] + elementType *property.Enum[string] + path *property.Primitive[string] + jsonPath *property.Primitive[string] + xmlPath *property.Primitive[string] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + xmlDataType *property.Primitive[string] + propType *property.Part[element.Element] + isKey *property.Primitive[bool] + isXmlAttribute *property.Primitive[bool] + xmlPrimitiveType *property.Enum[string] + isContent *property.Primitive[bool] + attribute *property.ByNameRef[element.Element] + converter *property.ByNameRef[element.Element] + expectedContentTypes *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + originalValue *property.Primitive[string] +} + +// Documentation returns the value of the documentation property. +func (o *ImportValueMappingElement) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ImportValueMappingElement) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// ElementType returns the value of the elementType property. +func (o *ImportValueMappingElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ImportValueMappingElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// Path returns the value of the path property. +func (o *ImportValueMappingElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ImportValueMappingElement) SetPath(v string) { + o.path.Set(v) +} + +// JsonPath returns the value of the jsonPath property. +func (o *ImportValueMappingElement) JsonPath() string { + return o.jsonPath.Get() +} + +// SetJsonPath sets the value of the jsonPath property. +func (o *ImportValueMappingElement) SetJsonPath(v string) { + o.jsonPath.Set(v) +} + +// XmlPath returns the value of the xmlPath property. +func (o *ImportValueMappingElement) XmlPath() string { + return o.xmlPath.Get() +} + +// SetXmlPath sets the value of the xmlPath property. +func (o *ImportValueMappingElement) SetXmlPath(v string) { + o.xmlPath.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ImportValueMappingElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ImportValueMappingElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ImportValueMappingElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ImportValueMappingElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ImportValueMappingElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ImportValueMappingElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ImportValueMappingElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ImportValueMappingElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// XmlDataType returns the value of the xmlDataType property. +func (o *ImportValueMappingElement) XmlDataType() string { + return o.xmlDataType.Get() +} + +// SetXmlDataType sets the value of the xmlDataType property. +func (o *ImportValueMappingElement) SetXmlDataType(v string) { + o.xmlDataType.Set(v) +} + +// Type returns the value of the type property. +func (o *ImportValueMappingElement) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *ImportValueMappingElement) SetType(v element.Element) { + o.propType.Set(v) +} + +// IsKey returns the value of the isKey property. +func (o *ImportValueMappingElement) IsKey() bool { + return o.isKey.Get() +} + +// SetIsKey sets the value of the isKey property. +func (o *ImportValueMappingElement) SetIsKey(v bool) { + o.isKey.Set(v) +} + +// IsXmlAttribute returns the value of the isXmlAttribute property. +func (o *ImportValueMappingElement) IsXmlAttribute() bool { + return o.isXmlAttribute.Get() +} + +// SetIsXmlAttribute sets the value of the isXmlAttribute property. +func (o *ImportValueMappingElement) SetIsXmlAttribute(v bool) { + o.isXmlAttribute.Set(v) +} + +// XmlPrimitiveType returns the value of the xmlPrimitiveType property. +func (o *ImportValueMappingElement) XmlPrimitiveType() string { + return o.xmlPrimitiveType.Get() +} + +// SetXmlPrimitiveType sets the value of the xmlPrimitiveType property. +func (o *ImportValueMappingElement) SetXmlPrimitiveType(v string) { + o.xmlPrimitiveType.Set(v) +} + +// IsContent returns the value of the isContent property. +func (o *ImportValueMappingElement) IsContent() bool { + return o.isContent.Get() +} + +// SetIsContent sets the value of the isContent property. +func (o *ImportValueMappingElement) SetIsContent(v bool) { + o.isContent.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ImportValueMappingElement) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ImportValueMappingElement) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// ConverterQualifiedName returns the value of the converter property. +func (o *ImportValueMappingElement) ConverterQualifiedName() string { + return o.converter.QualifiedName() +} + +// SetConverterQualifiedName sets the value of the converter property. +func (o *ImportValueMappingElement) SetConverterQualifiedName(v string) { + o.converter.SetQualifiedName(v) +} + +// ExpectedContentTypes returns the value of the expectedContentTypes property. +func (o *ImportValueMappingElement) ExpectedContentTypes() string { + return o.expectedContentTypes.Get() +} + +// SetExpectedContentTypes sets the value of the expectedContentTypes property. +func (o *ImportValueMappingElement) SetExpectedContentTypes(v string) { + o.expectedContentTypes.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *ImportValueMappingElement) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *ImportValueMappingElement) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *ImportValueMappingElement) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *ImportValueMappingElement) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *ImportValueMappingElement) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *ImportValueMappingElement) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// OriginalValue returns the value of the originalValue property. +func (o *ImportValueMappingElement) OriginalValue() string { + return o.originalValue.Get() +} + +// SetOriginalValue sets the value of the originalValue property. +func (o *ImportValueMappingElement) SetOriginalValue(v string) { + o.originalValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportValueMappingElement) InitFromRaw(raw bson.Raw) { + o.documentation.Init(raw) + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.jsonPath.Init(raw) + o.xmlPath.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.xmlDataType.Init(raw) + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } + o.isKey.Init(raw) + o.isXmlAttribute.Init(raw) + if val, err := raw.LookupErr("XmlPrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.xmlPrimitiveType.SetFromDecode(s) + } + } + o.isContent.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Converter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.converter.SetFromDecode(s) + } + } + o.expectedContentTypes.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.originalValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initImportMapping creates a ImportMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportMapping() *ImportMapping { + o := &ImportMapping{} + o.SetTypeName("ImportMappings$ImportMapping") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.rootMappingElements = property.NewPartList[element.Element]("RootMappingElements") + o.rootMappingElements.Bind(&o.Base, 4) + o.xmlSchema = property.NewByNameRef[element.Element]("XmlSchema", "XmlSchemas$XmlSchema") + o.xmlSchema.Bind(&o.Base, 5) + o.jsonStructure = property.NewByNameRef[element.Element]("JsonStructure", "JsonStructures$JsonStructure") + o.jsonStructure.Bind(&o.Base, 6) + o.rootElementName = property.NewPrimitive[string]("RootElementName", property.DecodeString) + o.rootElementName.Bind(&o.Base, 7) + o.importedWebService = property.NewByNameRef[element.Element]("ImportedWebService", "WebServices$ImportedWebService") + o.importedWebService.Bind(&o.Base, 8) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 9) + o.operationName = property.NewPrimitive[string]("OperationName", property.DecodeString) + o.operationName.Bind(&o.Base, 10) + o.messageDefinition = property.NewByNameRef[element.Element]("MessageDefinition", "MessageDefinitions$MessageDefinition") + o.messageDefinition.Bind(&o.Base, 11) + o.mappingSourceReference = property.NewPart[element.Element]("MappingSourceReference") + o.mappingSourceReference.Bind(&o.Base, 12) + o.publicName = property.NewPrimitive[string]("PublicName", property.DecodeString) + o.publicName.Bind(&o.Base, 13) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 14) + o.useSubtransactionsForMicroflows = property.NewPrimitive[bool]("UseSubtransactionsForMicroflows", property.DecodeBool) + o.useSubtransactionsForMicroflows.Bind(&o.Base, 15) + o.parameter = property.NewByNameRef[element.Element]("Parameter", "DomainModels$Entity") + o.parameter.Bind(&o.Base, 16) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.rootMappingElements, o.xmlSchema, o.jsonStructure, o.rootElementName, o.importedWebService, o.serviceName, o.operationName, o.messageDefinition, o.mappingSourceReference, o.publicName, o.parameterType, o.useSubtransactionsForMicroflows, o.parameter}) + return o +} + +// NewImportMapping creates a new ImportMapping for user code. Marked dirty (bit 63 = new element). +func NewImportMapping() *ImportMapping { + o := initImportMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImportObjectMappingElement creates a ImportObjectMappingElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportObjectMappingElement() *ImportObjectMappingElement { + o := &ImportObjectMappingElement{} + o.SetTypeName("ImportMappings$ObjectMappingElement") + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 0) + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.jsonPath = property.NewPrimitive[string]("JsonPath", property.DecodeString) + o.jsonPath.Bind(&o.Base, 3) + o.xmlPath = property.NewPrimitive[string]("XmlPath", property.DecodeString) + o.xmlPath.Bind(&o.Base, 4) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 5) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 6) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 7) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 8) + o.mappingMicroflowCall = property.NewPart[element.Element]("MappingMicroflowCall") + o.mappingMicroflowCall.Bind(&o.Base, 9) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 10) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 11) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 12) + o.objectHandling = property.NewEnum[string]("ObjectHandling") + o.objectHandling.Bind(&o.Base, 13) + o.objectHandlingBackup = property.NewEnum[string]("ObjectHandlingBackup") + o.objectHandlingBackup.Bind(&o.Base, 14) + o.objectHandlingBackupAllowOverride = property.NewPrimitive[bool]("ObjectHandlingBackupAllowOverride", property.DecodeBool) + o.objectHandlingBackupAllowOverride.Bind(&o.Base, 15) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 16) + o.SetProperties([]element.Property{o.documentation, o.elementType, o.path, o.jsonPath, o.xmlPath, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.mappingMicroflowCall, o.children, o.entity, o.association, o.objectHandling, o.objectHandlingBackup, o.objectHandlingBackupAllowOverride, o.isDefaultType}) + return o +} + +// NewImportObjectMappingElement creates a new ImportObjectMappingElement for user code. Marked dirty (bit 63 = new element). +func NewImportObjectMappingElement() *ImportObjectMappingElement { + o := initImportObjectMappingElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImportValueMappingElement creates a ImportValueMappingElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportValueMappingElement() *ImportValueMappingElement { + o := &ImportValueMappingElement{} + o.SetTypeName("ImportMappings$ValueMappingElement") + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 0) + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.jsonPath = property.NewPrimitive[string]("JsonPath", property.DecodeString) + o.jsonPath.Bind(&o.Base, 3) + o.xmlPath = property.NewPrimitive[string]("XmlPath", property.DecodeString) + o.xmlPath.Bind(&o.Base, 4) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 5) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 6) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 7) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 8) + o.xmlDataType = property.NewPrimitive[string]("XmlDataType", property.DecodeString) + o.xmlDataType.Bind(&o.Base, 9) + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 10) + o.isKey = property.NewPrimitive[bool]("IsKey", property.DecodeBool) + o.isKey.Bind(&o.Base, 11) + o.isXmlAttribute = property.NewPrimitive[bool]("IsXmlAttribute", property.DecodeBool) + o.isXmlAttribute.Bind(&o.Base, 12) + o.xmlPrimitiveType = property.NewEnum[string]("XmlPrimitiveType") + o.xmlPrimitiveType.Bind(&o.Base, 13) + o.isContent = property.NewPrimitive[bool]("IsContent", property.DecodeBool) + o.isContent.Bind(&o.Base, 14) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 15) + o.converter = property.NewByNameRef[element.Element]("Converter", "Microflows$Microflow") + o.converter.Bind(&o.Base, 16) + o.expectedContentTypes = property.NewPrimitive[string]("ExpectedContentTypes", property.DecodeString) + o.expectedContentTypes.Bind(&o.Base, 17) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 18) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 19) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 20) + o.originalValue = property.NewPrimitive[string]("OriginalValue", property.DecodeString) + o.originalValue.Bind(&o.Base, 21) + o.SetProperties([]element.Property{o.documentation, o.elementType, o.path, o.jsonPath, o.xmlPath, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.xmlDataType, o.propType, o.isKey, o.isXmlAttribute, o.xmlPrimitiveType, o.isContent, o.attribute, o.converter, o.expectedContentTypes, o.maxLength, o.fractionDigits, o.totalDigits, o.originalValue}) + return o +} + +// NewImportValueMappingElement creates a new ImportValueMappingElement for user code. Marked dirty (bit 63 = new element). +func NewImportValueMappingElement() *ImportValueMappingElement { + o := initImportValueMappingElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("ImportMappings$ImportMapping", func() element.Element { + return initImportMapping() + }) + codec.DefaultRegistry.Register("ImportMappings$ImportObjectMappingElement", func() element.Element { + o := initImportObjectMappingElement() + o.SetTypeName("ImportMappings$ImportObjectMappingElement") + return o + }) + codec.DefaultRegistry.Register("ImportMappings$ObjectMappingElement", func() element.Element { + return initImportObjectMappingElement() + }) + codec.DefaultRegistry.Register("ImportMappings$ImportValueMappingElement", func() element.Element { + o := initImportValueMappingElement() + o.SetTypeName("ImportMappings$ImportValueMappingElement") + return o + }) + codec.DefaultRegistry.Register("ImportMappings$ValueMappingElement", func() element.Element { + return initImportValueMappingElement() + }) +} diff --git a/modelsdk/gen/importmappings/version.go b/modelsdk/gen/importmappings/version.go new file mode 100644 index 00000000..3f53f9a4 --- /dev/null +++ b/modelsdk/gen/importmappings/version.go @@ -0,0 +1,17 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package importmappings + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "ImportMappings$ImportMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Deleted: "7.16.0"}, + "parameterType": {Introduced: "7.16.0", Required: true}, + }, + }, +} diff --git a/modelsdk/gen/integrationoverview/enums.go b/modelsdk/gen/integrationoverview/enums.go new file mode 100644 index 00000000..c38acf44 --- /dev/null +++ b/modelsdk/gen/integrationoverview/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package integrationoverview diff --git a/modelsdk/gen/integrationoverview/refs.go b/modelsdk/gen/integrationoverview/refs.go new file mode 100644 index 00000000..c38acf44 --- /dev/null +++ b/modelsdk/gen/integrationoverview/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package integrationoverview diff --git a/modelsdk/gen/integrationoverview/types.go b/modelsdk/gen/integrationoverview/types.go new file mode 100644 index 00000000..fb7731ef --- /dev/null +++ b/modelsdk/gen/integrationoverview/types.go @@ -0,0 +1,161 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package integrationoverview + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// SourceApi +// ──────────────────────────────────────────────────────── + +type SourceApi struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SourceApi) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CatalogApi +// ──────────────────────────────────────────────────────── + +type CatalogApi struct { + element.Base + endpointId *property.Primitive[string] + version *property.Primitive[string] + applicationId *property.Primitive[string] + environmentType *property.Enum[string] + viewInCatalogUrl *property.Primitive[string] + validated *property.Primitive[bool] +} + +// EndpointId returns the value of the endpointId property. +func (o *CatalogApi) EndpointId() string { + return o.endpointId.Get() +} + +// SetEndpointId sets the value of the endpointId property. +func (o *CatalogApi) SetEndpointId(v string) { + o.endpointId.Set(v) +} + +// Version returns the value of the version property. +func (o *CatalogApi) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *CatalogApi) SetVersion(v string) { + o.version.Set(v) +} + +// ApplicationId returns the value of the applicationId property. +func (o *CatalogApi) ApplicationId() string { + return o.applicationId.Get() +} + +// SetApplicationId sets the value of the applicationId property. +func (o *CatalogApi) SetApplicationId(v string) { + o.applicationId.Set(v) +} + +// EnvironmentType returns the value of the environmentType property. +func (o *CatalogApi) EnvironmentType() string { + return o.environmentType.Get() +} + +// SetEnvironmentType sets the value of the environmentType property. +func (o *CatalogApi) SetEnvironmentType(v string) { + o.environmentType.Set(v) +} + +// ViewInCatalogUrl returns the value of the viewInCatalogUrl property. +func (o *CatalogApi) ViewInCatalogUrl() string { + return o.viewInCatalogUrl.Get() +} + +// SetViewInCatalogUrl sets the value of the viewInCatalogUrl property. +func (o *CatalogApi) SetViewInCatalogUrl(v string) { + o.viewInCatalogUrl.Set(v) +} + +// Validated returns the value of the validated property. +func (o *CatalogApi) Validated() bool { + return o.validated.Get() +} + +// SetValidated sets the value of the validated property. +func (o *CatalogApi) SetValidated(v bool) { + o.validated.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CatalogApi) InitFromRaw(raw bson.Raw) { + o.endpointId.Init(raw) + o.version.Init(raw) + o.applicationId.Init(raw) + if val, err := raw.LookupErr("EnvironmentType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.environmentType.SetFromDecode(s) + } + } + o.viewInCatalogUrl.Init(raw) + o.validated.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initCatalogApi creates a CatalogApi with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCatalogApi() *CatalogApi { + o := &CatalogApi{} + o.SetTypeName("IntegrationOverview$CatalogApi") + o.endpointId = property.NewPrimitive[string]("EndpointId", property.DecodeString) + o.endpointId.Bind(&o.Base, 0) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 1) + o.applicationId = property.NewPrimitive[string]("ApplicationId", property.DecodeString) + o.applicationId.Bind(&o.Base, 2) + o.environmentType = property.NewEnum[string]("EnvironmentType") + o.environmentType.Bind(&o.Base, 3) + o.viewInCatalogUrl = property.NewPrimitive[string]("ViewInCatalogUrl", property.DecodeString) + o.viewInCatalogUrl.Bind(&o.Base, 4) + o.validated = property.NewPrimitive[bool]("Validated", property.DecodeBool) + o.validated.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.endpointId, o.version, o.applicationId, o.environmentType, o.viewInCatalogUrl, o.validated}) + return o +} + +// NewCatalogApi creates a new CatalogApi for user code. Marked dirty (bit 63 = new element). +func NewCatalogApi() *CatalogApi { + o := initCatalogApi() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("IntegrationOverview$CatalogApi", func() element.Element { + return initCatalogApi() + }) +} diff --git a/modelsdk/gen/integrationoverview/version.go b/modelsdk/gen/integrationoverview/version.go new file mode 100644 index 00000000..f4e349dd --- /dev/null +++ b/modelsdk/gen/integrationoverview/version.go @@ -0,0 +1,10 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package integrationoverview + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{} diff --git a/modelsdk/gen/javaactions/enums.go b/modelsdk/gen/javaactions/enums.go new file mode 100644 index 00000000..f07ce0f6 --- /dev/null +++ b/modelsdk/gen/javaactions/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package javaactions diff --git a/modelsdk/gen/javaactions/refs.go b/modelsdk/gen/javaactions/refs.go new file mode 100644 index 00000000..c3703fec --- /dev/null +++ b/modelsdk/gen/javaactions/refs.go @@ -0,0 +1,25 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package javaactions + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("JavaActions$ConcreteEntityType", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("JavaActions$EntityTypeParameterType", []codec.RefMeta{ + {Prop: "TypeParameterPointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("JavaActions$EnumerationType", []codec.RefMeta{ + {Prop: "Enumeration", Kind: codec.RefByName, Target: "Enumerations$Enumeration"}, + }) + codec.DefaultRefRegistry.RegisterRefs("JavaActions$MicroflowActionInfo", []codec.RefMeta{ + {Prop: "Icon", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("JavaActions$ParameterizedEntityType", []codec.RefMeta{ + {Prop: "TypeParameterPointer", Kind: codec.RefById, Target: ""}, + }) +} diff --git a/modelsdk/gen/javaactions/types.go b/modelsdk/gen/javaactions/types.go new file mode 100644 index 00000000..463dad39 --- /dev/null +++ b/modelsdk/gen/javaactions/types.go @@ -0,0 +1,1367 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package javaactions + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// ParameterType +// ──────────────────────────────────────────────────────── + +type ParameterType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ParameterType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BasicParameterType +// ──────────────────────────────────────────────────────── + +type BasicParameterType struct { + element.Base + propType *property.Part[element.Element] +} + +// Type returns the value of the type property. +func (o *BasicParameterType) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *BasicParameterType) SetType(v element.Element) { + o.propType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicParameterType) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Type +// ──────────────────────────────────────────────────────── + +type Type struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Type) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// PrimitiveType +// ──────────────────────────────────────────────────────── + +type PrimitiveType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PrimitiveType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BooleanType +// ──────────────────────────────────────────────────────── + +type BooleanType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BooleanType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EntityType +// ──────────────────────────────────────────────────────── + +type EntityType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ConcreteEntityType +// ──────────────────────────────────────────────────────── + +type ConcreteEntityType struct { + element.Base + entity *property.ByNameRef[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ConcreteEntityType) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ConcreteEntityType) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConcreteEntityType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// DateTimeType +// ──────────────────────────────────────────────────────── + +type DateTimeType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DateTimeType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// DecimalType +// ──────────────────────────────────────────────────────── + +type DecimalType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DecimalType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EntityTypeParameterType +// ──────────────────────────────────────────────────────── + +type EntityTypeParameterType struct { + element.Base + typeParameter *property.ByIdRef[element.Element] +} + +// TypeParameterRefID returns the value of the typeParameter property. +func (o *EntityTypeParameterType) TypeParameterRefID() element.ID { + return o.typeParameter.RefID() +} + +// SetTypeParameterID sets the value of the typeParameter property. +func (o *EntityTypeParameterType) SetTypeParameterID(v element.ID) { + o.typeParameter.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityTypeParameterType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("TypeParameterPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.typeParameter.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.typeParameter.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// EnumerationType +// ──────────────────────────────────────────────────────── + +type EnumerationType struct { + element.Base + enumeration *property.ByNameRef[element.Element] +} + +// EnumerationQualifiedName returns the value of the enumeration property. +func (o *EnumerationType) EnumerationQualifiedName() string { + return o.enumeration.QualifiedName() +} + +// SetEnumerationQualifiedName sets the value of the enumeration property. +func (o *EnumerationType) SetEnumerationQualifiedName(v string) { + o.enumeration.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EnumerationType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Enumeration"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.enumeration.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ExportMappingJavaActionParameterType +// ──────────────────────────────────────────────────────── + +type ExportMappingJavaActionParameterType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExportMappingJavaActionParameterType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ExportMappingParameterType +// ──────────────────────────────────────────────────────── + +type ExportMappingParameterType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExportMappingParameterType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// FloatType +// ──────────────────────────────────────────────────────── + +type FloatType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FloatType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ImportMappingJavaActionParameterType +// ──────────────────────────────────────────────────────── + +type ImportMappingJavaActionParameterType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportMappingJavaActionParameterType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ImportMappingParameterType +// ──────────────────────────────────────────────────────── + +type ImportMappingParameterType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportMappingParameterType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// IntegerType +// ──────────────────────────────────────────────────────── + +type IntegerType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IntegerType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// JavaAction +// ──────────────────────────────────────────────────────── + +type JavaAction struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + actionTypeParameters *property.PartList[element.Element] + actionReturnType *property.Part[element.Element] + actionDefaultReturnName *property.Primitive[string] + modelerActionInfo *property.Part[element.Element] + actionParameters *property.PartList[element.Element] + typeParameters *property.PartList[element.Element] + parameters *property.PartList[element.Element] + returnType *property.Primitive[string] + javaReturnType *property.Part[element.Element] + microflowActionInfo *property.Part[element.Element] + useLegacyCodeGeneration *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *JavaAction) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *JavaAction) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *JavaAction) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *JavaAction) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *JavaAction) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *JavaAction) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *JavaAction) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *JavaAction) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ActionTypeParametersItems returns the value of the actionTypeParameters property. +func (o *JavaAction) ActionTypeParametersItems() []element.Element { + return o.actionTypeParameters.Items() +} + +// AddActionTypeParameters appends a child element to the actionTypeParameters list. +func (o *JavaAction) AddActionTypeParameters(v element.Element) { + o.actionTypeParameters.Append(v) +} + +// RemoveActionTypeParameters removes the element at the given index from the actionTypeParameters list. +func (o *JavaAction) RemoveActionTypeParameters(index int) { + o.actionTypeParameters.Remove(index) +} + +// ActionReturnType returns the value of the actionReturnType property. +func (o *JavaAction) ActionReturnType() element.Element { + return o.actionReturnType.Get() +} + +// SetActionReturnType sets the value of the actionReturnType property. +func (o *JavaAction) SetActionReturnType(v element.Element) { + o.actionReturnType.Set(v) +} + +// ActionDefaultReturnName returns the value of the actionDefaultReturnName property. +func (o *JavaAction) ActionDefaultReturnName() string { + return o.actionDefaultReturnName.Get() +} + +// SetActionDefaultReturnName sets the value of the actionDefaultReturnName property. +func (o *JavaAction) SetActionDefaultReturnName(v string) { + o.actionDefaultReturnName.Set(v) +} + +// ModelerActionInfo returns the value of the modelerActionInfo property. +func (o *JavaAction) ModelerActionInfo() element.Element { + return o.modelerActionInfo.Get() +} + +// SetModelerActionInfo sets the value of the modelerActionInfo property. +func (o *JavaAction) SetModelerActionInfo(v element.Element) { + o.modelerActionInfo.Set(v) +} + +// ActionParametersItems returns the value of the actionParameters property. +func (o *JavaAction) ActionParametersItems() []element.Element { + return o.actionParameters.Items() +} + +// AddActionParameters appends a child element to the actionParameters list. +func (o *JavaAction) AddActionParameters(v element.Element) { + o.actionParameters.Append(v) +} + +// RemoveActionParameters removes the element at the given index from the actionParameters list. +func (o *JavaAction) RemoveActionParameters(index int) { + o.actionParameters.Remove(index) +} + +// TypeParametersItems returns the value of the typeParameters property. +func (o *JavaAction) TypeParametersItems() []element.Element { + return o.typeParameters.Items() +} + +// AddTypeParameters appends a child element to the typeParameters list. +func (o *JavaAction) AddTypeParameters(v element.Element) { + o.typeParameters.Append(v) +} + +// RemoveTypeParameters removes the element at the given index from the typeParameters list. +func (o *JavaAction) RemoveTypeParameters(index int) { + o.typeParameters.Remove(index) +} + +// ParametersItems returns the value of the parameters property. +func (o *JavaAction) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *JavaAction) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *JavaAction) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// ReturnType returns the value of the returnType property. +func (o *JavaAction) ReturnType() string { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *JavaAction) SetReturnType(v string) { + o.returnType.Set(v) +} + +// JavaReturnType returns the value of the javaReturnType property. +func (o *JavaAction) JavaReturnType() element.Element { + return o.javaReturnType.Get() +} + +// SetJavaReturnType sets the value of the javaReturnType property. +func (o *JavaAction) SetJavaReturnType(v element.Element) { + o.javaReturnType.Set(v) +} + +// MicroflowActionInfo returns the value of the microflowActionInfo property. +func (o *JavaAction) MicroflowActionInfo() element.Element { + return o.microflowActionInfo.Get() +} + +// SetMicroflowActionInfo sets the value of the microflowActionInfo property. +func (o *JavaAction) SetMicroflowActionInfo(v element.Element) { + o.microflowActionInfo.Set(v) +} + +// UseLegacyCodeGeneration returns the value of the useLegacyCodeGeneration property. +func (o *JavaAction) UseLegacyCodeGeneration() bool { + return o.useLegacyCodeGeneration.Get() +} + +// SetUseLegacyCodeGeneration sets the value of the useLegacyCodeGeneration property. +func (o *JavaAction) SetUseLegacyCodeGeneration(v bool) { + o.useLegacyCodeGeneration.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaAction) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "ActionTypeParameters"); err == nil { + for _, child := range children { + o.actionTypeParameters.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ActionReturnType"); err == nil { + o.actionReturnType.SetFromDecode(child) + } + o.actionDefaultReturnName.Init(raw) + if child, err := codec.DecodeChild(raw, "ModelerActionInfo"); err == nil { + o.modelerActionInfo.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "ActionParameters"); err == nil { + for _, child := range children { + o.actionParameters.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "TypeParameters"); err == nil { + for _, child := range children { + o.typeParameters.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + o.returnType.Init(raw) + if child, err := codec.DecodeChild(raw, "JavaReturnType"); err == nil { + o.javaReturnType.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "MicroflowActionInfo"); err == nil { + o.microflowActionInfo.SetFromDecode(child) + } + o.useLegacyCodeGeneration.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// JavaActionParameter +// ──────────────────────────────────────────────────────── + +type JavaActionParameter struct { + element.Base + name *property.Primitive[string] + actionParameterType *property.Part[element.Element] + description *property.Primitive[string] + category *property.Primitive[string] + isRequired *property.Primitive[bool] + propType *property.Primitive[string] + javaType *property.Part[element.Element] + parameterType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *JavaActionParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *JavaActionParameter) SetName(v string) { + o.name.Set(v) +} + +// ActionParameterType returns the value of the actionParameterType property. +func (o *JavaActionParameter) ActionParameterType() element.Element { + return o.actionParameterType.Get() +} + +// SetActionParameterType sets the value of the actionParameterType property. +func (o *JavaActionParameter) SetActionParameterType(v element.Element) { + o.actionParameterType.Set(v) +} + +// Description returns the value of the description property. +func (o *JavaActionParameter) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *JavaActionParameter) SetDescription(v string) { + o.description.Set(v) +} + +// Category returns the value of the category property. +func (o *JavaActionParameter) Category() string { + return o.category.Get() +} + +// SetCategory sets the value of the category property. +func (o *JavaActionParameter) SetCategory(v string) { + o.category.Set(v) +} + +// IsRequired returns the value of the isRequired property. +func (o *JavaActionParameter) IsRequired() bool { + return o.isRequired.Get() +} + +// SetIsRequired sets the value of the isRequired property. +func (o *JavaActionParameter) SetIsRequired(v bool) { + o.isRequired.Set(v) +} + +// Type returns the value of the type property. +func (o *JavaActionParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *JavaActionParameter) SetType(v string) { + o.propType.Set(v) +} + +// JavaType returns the value of the javaType property. +func (o *JavaActionParameter) JavaType() element.Element { + return o.javaType.Get() +} + +// SetJavaType sets the value of the javaType property. +func (o *JavaActionParameter) SetJavaType(v element.Element) { + o.javaType.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *JavaActionParameter) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *JavaActionParameter) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaActionParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "ActionParameterType"); err == nil { + o.actionParameterType.SetFromDecode(child) + } + o.description.Init(raw) + o.category.Init(raw) + o.isRequired.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "JavaType"); err == nil { + o.javaType.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ListType +// ──────────────────────────────────────────────────────── + +type ListType struct { + element.Base + parameter *property.Part[element.Element] +} + +// Parameter returns the value of the parameter property. +func (o *ListType) Parameter() element.Element { + return o.parameter.Get() +} + +// SetParameter sets the value of the parameter property. +func (o *ListType) SetParameter(v element.Element) { + o.parameter.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListType) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Parameter"); err == nil { + o.parameter.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowActionInfo +// ──────────────────────────────────────────────────────── + +type MicroflowActionInfo struct { + element.Base + caption *property.Primitive[string] + category *property.Primitive[string] + icon *property.ByNameRef[element.Element] +} + +// Caption returns the value of the caption property. +func (o *MicroflowActionInfo) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *MicroflowActionInfo) SetCaption(v string) { + o.caption.Set(v) +} + +// Category returns the value of the category property. +func (o *MicroflowActionInfo) Category() string { + return o.category.Get() +} + +// SetCategory sets the value of the category property. +func (o *MicroflowActionInfo) SetCategory(v string) { + o.category.Set(v) +} + +// IconQualifiedName returns the value of the icon property. +func (o *MicroflowActionInfo) IconQualifiedName() string { + return o.icon.QualifiedName() +} + +// SetIconQualifiedName sets the value of the icon property. +func (o *MicroflowActionInfo) SetIconQualifiedName(v string) { + o.icon.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowActionInfo) InitFromRaw(raw bson.Raw) { + o.caption.Init(raw) + o.category.Init(raw) + if val, err := raw.LookupErr("Icon"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.icon.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowJavaActionParameterType +// ──────────────────────────────────────────────────────── + +type MicroflowJavaActionParameterType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowJavaActionParameterType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// MicroflowParameterType +// ──────────────────────────────────────────────────────── + +type MicroflowParameterType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowParameterType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ParameterizedEntityType +// ──────────────────────────────────────────────────────── + +type ParameterizedEntityType struct { + element.Base + typeParameter *property.ByIdRef[element.Element] +} + +// TypeParameterRefID returns the value of the typeParameter property. +func (o *ParameterizedEntityType) TypeParameterRefID() element.ID { + return o.typeParameter.RefID() +} + +// SetTypeParameterID sets the value of the typeParameter property. +func (o *ParameterizedEntityType) SetTypeParameterID(v element.ID) { + o.typeParameter.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ParameterizedEntityType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("TypeParameterPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.typeParameter.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.typeParameter.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// StringType +// ──────────────────────────────────────────────────────── + +type StringType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// TypeParameter +// ──────────────────────────────────────────────────────── + +type TypeParameter struct { + element.Base + name *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *TypeParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TypeParameter) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TypeParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initBasicParameterType creates a BasicParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicParameterType() *BasicParameterType { + o := &BasicParameterType{} + o.SetTypeName("JavaActions$BasicParameterType") + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.propType}) + return o +} + +// NewBasicParameterType creates a new BasicParameterType for user code. Marked dirty (bit 63 = new element). +func NewBasicParameterType() *BasicParameterType { + o := initBasicParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBooleanType creates a BooleanType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBooleanType() *BooleanType { + o := &BooleanType{} + o.SetTypeName("JavaActions$BooleanType") + o.SetProperties([]element.Property{}) + return o +} + +// NewBooleanType creates a new BooleanType for user code. Marked dirty (bit 63 = new element). +func NewBooleanType() *BooleanType { + o := initBooleanType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConcreteEntityType creates a ConcreteEntityType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConcreteEntityType() *ConcreteEntityType { + o := &ConcreteEntityType{} + o.SetTypeName("JavaActions$ConcreteEntityType") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.entity}) + return o +} + +// NewConcreteEntityType creates a new ConcreteEntityType for user code. Marked dirty (bit 63 = new element). +func NewConcreteEntityType() *ConcreteEntityType { + o := initConcreteEntityType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDateTimeType creates a DateTimeType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDateTimeType() *DateTimeType { + o := &DateTimeType{} + o.SetTypeName("JavaActions$DateTimeType") + o.SetProperties([]element.Property{}) + return o +} + +// NewDateTimeType creates a new DateTimeType for user code. Marked dirty (bit 63 = new element). +func NewDateTimeType() *DateTimeType { + o := initDateTimeType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDecimalType creates a DecimalType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDecimalType() *DecimalType { + o := &DecimalType{} + o.SetTypeName("JavaActions$DecimalType") + o.SetProperties([]element.Property{}) + return o +} + +// NewDecimalType creates a new DecimalType for user code. Marked dirty (bit 63 = new element). +func NewDecimalType() *DecimalType { + o := initDecimalType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityTypeParameterType creates a EntityTypeParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityTypeParameterType() *EntityTypeParameterType { + o := &EntityTypeParameterType{} + o.SetTypeName("JavaActions$EntityTypeParameterType") + o.typeParameter = property.NewByIdRef[element.Element]("TypeParameterPointer") + o.typeParameter.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.typeParameter}) + return o +} + +// NewEntityTypeParameterType creates a new EntityTypeParameterType for user code. Marked dirty (bit 63 = new element). +func NewEntityTypeParameterType() *EntityTypeParameterType { + o := initEntityTypeParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEnumerationType creates a EnumerationType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEnumerationType() *EnumerationType { + o := &EnumerationType{} + o.SetTypeName("JavaActions$EnumerationType") + o.enumeration = property.NewByNameRef[element.Element]("Enumeration", "Enumerations$Enumeration") + o.enumeration.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.enumeration}) + return o +} + +// NewEnumerationType creates a new EnumerationType for user code. Marked dirty (bit 63 = new element). +func NewEnumerationType() *EnumerationType { + o := initEnumerationType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExportMappingJavaActionParameterType creates a ExportMappingJavaActionParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExportMappingJavaActionParameterType() *ExportMappingJavaActionParameterType { + o := &ExportMappingJavaActionParameterType{} + o.SetTypeName("JavaActions$ExportMappingJavaActionParameterType") + o.SetProperties([]element.Property{}) + return o +} + +// NewExportMappingJavaActionParameterType creates a new ExportMappingJavaActionParameterType for user code. Marked dirty (bit 63 = new element). +func NewExportMappingJavaActionParameterType() *ExportMappingJavaActionParameterType { + o := initExportMappingJavaActionParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExportMappingParameterType creates a ExportMappingParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExportMappingParameterType() *ExportMappingParameterType { + o := &ExportMappingParameterType{} + o.SetTypeName("JavaActions$ExportMappingParameterType") + o.SetProperties([]element.Property{}) + return o +} + +// NewExportMappingParameterType creates a new ExportMappingParameterType for user code. Marked dirty (bit 63 = new element). +func NewExportMappingParameterType() *ExportMappingParameterType { + o := initExportMappingParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFloatType creates a FloatType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFloatType() *FloatType { + o := &FloatType{} + o.SetTypeName("JavaActions$FloatType") + o.SetProperties([]element.Property{}) + return o +} + +// NewFloatType creates a new FloatType for user code. Marked dirty (bit 63 = new element). +func NewFloatType() *FloatType { + o := initFloatType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImportMappingJavaActionParameterType creates a ImportMappingJavaActionParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportMappingJavaActionParameterType() *ImportMappingJavaActionParameterType { + o := &ImportMappingJavaActionParameterType{} + o.SetTypeName("JavaActions$ImportMappingJavaActionParameterType") + o.SetProperties([]element.Property{}) + return o +} + +// NewImportMappingJavaActionParameterType creates a new ImportMappingJavaActionParameterType for user code. Marked dirty (bit 63 = new element). +func NewImportMappingJavaActionParameterType() *ImportMappingJavaActionParameterType { + o := initImportMappingJavaActionParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImportMappingParameterType creates a ImportMappingParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportMappingParameterType() *ImportMappingParameterType { + o := &ImportMappingParameterType{} + o.SetTypeName("JavaActions$ImportMappingParameterType") + o.SetProperties([]element.Property{}) + return o +} + +// NewImportMappingParameterType creates a new ImportMappingParameterType for user code. Marked dirty (bit 63 = new element). +func NewImportMappingParameterType() *ImportMappingParameterType { + o := initImportMappingParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIntegerType creates a IntegerType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIntegerType() *IntegerType { + o := &IntegerType{} + o.SetTypeName("JavaActions$IntegerType") + o.SetProperties([]element.Property{}) + return o +} + +// NewIntegerType creates a new IntegerType for user code. Marked dirty (bit 63 = new element). +func NewIntegerType() *IntegerType { + o := initIntegerType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJavaAction creates a JavaAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJavaAction() *JavaAction { + o := &JavaAction{} + o.SetTypeName("JavaActions$JavaAction") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.actionTypeParameters = property.NewPartList[element.Element]("ActionTypeParameters") + o.actionTypeParameters.Bind(&o.Base, 4) + o.actionReturnType = property.NewPart[element.Element]("ActionReturnType") + o.actionReturnType.Bind(&o.Base, 5) + o.actionDefaultReturnName = property.NewPrimitive[string]("ActionDefaultReturnName", property.DecodeString) + o.actionDefaultReturnName.Bind(&o.Base, 6) + o.modelerActionInfo = property.NewPart[element.Element]("ModelerActionInfo") + o.modelerActionInfo.Bind(&o.Base, 7) + o.actionParameters = property.NewPartList[element.Element]("ActionParameters") + o.actionParameters.Bind(&o.Base, 8) + o.typeParameters = property.NewPartList[element.Element]("TypeParameters") + o.typeParameters.Bind(&o.Base, 9) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 10) + o.returnType = property.NewPrimitive[string]("ReturnType", property.DecodeString) + o.returnType.Bind(&o.Base, 11) + o.javaReturnType = property.NewPart[element.Element]("JavaReturnType") + o.javaReturnType.Bind(&o.Base, 12) + o.microflowActionInfo = property.NewPart[element.Element]("MicroflowActionInfo") + o.microflowActionInfo.Bind(&o.Base, 13) + o.useLegacyCodeGeneration = property.NewPrimitive[bool]("UseLegacyCodeGeneration", property.DecodeBool) + o.useLegacyCodeGeneration.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.actionTypeParameters, o.actionReturnType, o.actionDefaultReturnName, o.modelerActionInfo, o.actionParameters, o.typeParameters, o.parameters, o.returnType, o.javaReturnType, o.microflowActionInfo, o.useLegacyCodeGeneration}) + return o +} + +// NewJavaAction creates a new JavaAction for user code. Marked dirty (bit 63 = new element). +func NewJavaAction() *JavaAction { + o := initJavaAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJavaActionParameter creates a JavaActionParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJavaActionParameter() *JavaActionParameter { + o := &JavaActionParameter{} + o.SetTypeName("JavaActions$JavaActionParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.actionParameterType = property.NewPart[element.Element]("ActionParameterType") + o.actionParameterType.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.category = property.NewPrimitive[string]("Category", property.DecodeString) + o.category.Bind(&o.Base, 3) + o.isRequired = property.NewPrimitive[bool]("IsRequired", property.DecodeBool) + o.isRequired.Bind(&o.Base, 4) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 5) + o.javaType = property.NewPart[element.Element]("JavaType") + o.javaType.Bind(&o.Base, 6) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.actionParameterType, o.description, o.category, o.isRequired, o.propType, o.javaType, o.parameterType}) + return o +} + +// NewJavaActionParameter creates a new JavaActionParameter for user code. Marked dirty (bit 63 = new element). +func NewJavaActionParameter() *JavaActionParameter { + o := initJavaActionParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListType creates a ListType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListType() *ListType { + o := &ListType{} + o.SetTypeName("JavaActions$ListType") + o.parameter = property.NewPart[element.Element]("Parameter") + o.parameter.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.parameter}) + return o +} + +// NewListType creates a new ListType for user code. Marked dirty (bit 63 = new element). +func NewListType() *ListType { + o := initListType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowActionInfo creates a MicroflowActionInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowActionInfo() *MicroflowActionInfo { + o := &MicroflowActionInfo{} + o.SetTypeName("JavaActions$MicroflowActionInfo") + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 0) + o.category = property.NewPrimitive[string]("Category", property.DecodeString) + o.category.Bind(&o.Base, 1) + o.icon = property.NewByNameRef[element.Element]("Icon", "Images$Image") + o.icon.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.caption, o.category, o.icon}) + return o +} + +// NewMicroflowActionInfo creates a new MicroflowActionInfo for user code. Marked dirty (bit 63 = new element). +func NewMicroflowActionInfo() *MicroflowActionInfo { + o := initMicroflowActionInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowJavaActionParameterType creates a MicroflowJavaActionParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowJavaActionParameterType() *MicroflowJavaActionParameterType { + o := &MicroflowJavaActionParameterType{} + o.SetTypeName("JavaActions$MicroflowJavaActionParameterType") + o.SetProperties([]element.Property{}) + return o +} + +// NewMicroflowJavaActionParameterType creates a new MicroflowJavaActionParameterType for user code. Marked dirty (bit 63 = new element). +func NewMicroflowJavaActionParameterType() *MicroflowJavaActionParameterType { + o := initMicroflowJavaActionParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowParameterType creates a MicroflowParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowParameterType() *MicroflowParameterType { + o := &MicroflowParameterType{} + o.SetTypeName("JavaActions$MicroflowParameterType") + o.SetProperties([]element.Property{}) + return o +} + +// NewMicroflowParameterType creates a new MicroflowParameterType for user code. Marked dirty (bit 63 = new element). +func NewMicroflowParameterType() *MicroflowParameterType { + o := initMicroflowParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initParameterizedEntityType creates a ParameterizedEntityType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initParameterizedEntityType() *ParameterizedEntityType { + o := &ParameterizedEntityType{} + o.SetTypeName("JavaActions$ParameterizedEntityType") + o.typeParameter = property.NewByIdRef[element.Element]("TypeParameterPointer") + o.typeParameter.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.typeParameter}) + return o +} + +// NewParameterizedEntityType creates a new ParameterizedEntityType for user code. Marked dirty (bit 63 = new element). +func NewParameterizedEntityType() *ParameterizedEntityType { + o := initParameterizedEntityType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringType creates a StringType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringType() *StringType { + o := &StringType{} + o.SetTypeName("JavaActions$StringType") + o.SetProperties([]element.Property{}) + return o +} + +// NewStringType creates a new StringType for user code. Marked dirty (bit 63 = new element). +func NewStringType() *StringType { + o := initStringType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTypeParameter creates a TypeParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTypeParameter() *TypeParameter { + o := &TypeParameter{} + o.SetTypeName("JavaActions$TypeParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.name}) + return o +} + +// NewTypeParameter creates a new TypeParameter for user code. Marked dirty (bit 63 = new element). +func NewTypeParameter() *TypeParameter { + o := initTypeParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("JavaActions$BasicParameterType", func() element.Element { + return initBasicParameterType() + }) + codec.DefaultRegistry.Register("JavaActions$BooleanType", func() element.Element { + return initBooleanType() + }) + codec.DefaultRegistry.Register("JavaActions$ConcreteEntityType", func() element.Element { + return initConcreteEntityType() + }) + codec.DefaultRegistry.Register("JavaActions$DateTimeType", func() element.Element { + return initDateTimeType() + }) + codec.DefaultRegistry.Register("JavaActions$DecimalType", func() element.Element { + return initDecimalType() + }) + codec.DefaultRegistry.Register("JavaActions$EntityTypeParameterType", func() element.Element { + return initEntityTypeParameterType() + }) + codec.DefaultRegistry.Register("JavaActions$EnumerationType", func() element.Element { + return initEnumerationType() + }) + codec.DefaultRegistry.Register("JavaActions$ExportMappingJavaActionParameterType", func() element.Element { + return initExportMappingJavaActionParameterType() + }) + codec.DefaultRegistry.Register("JavaActions$ExportMappingParameterType", func() element.Element { + return initExportMappingParameterType() + }) + codec.DefaultRegistry.Register("JavaActions$FloatType", func() element.Element { + return initFloatType() + }) + codec.DefaultRegistry.Register("JavaActions$ImportMappingJavaActionParameterType", func() element.Element { + return initImportMappingJavaActionParameterType() + }) + codec.DefaultRegistry.Register("JavaActions$ImportMappingParameterType", func() element.Element { + return initImportMappingParameterType() + }) + codec.DefaultRegistry.Register("JavaActions$IntegerType", func() element.Element { + return initIntegerType() + }) + codec.DefaultRegistry.Register("JavaActions$JavaAction", func() element.Element { + return initJavaAction() + }) + codec.DefaultRegistry.Register("JavaActions$JavaActionParameter", func() element.Element { + return initJavaActionParameter() + }) + codec.DefaultRegistry.Register("JavaActions$ListType", func() element.Element { + return initListType() + }) + codec.DefaultRegistry.Register("JavaActions$MicroflowActionInfo", func() element.Element { + return initMicroflowActionInfo() + }) + codec.DefaultRegistry.Register("JavaActions$MicroflowJavaActionParameterType", func() element.Element { + return initMicroflowJavaActionParameterType() + }) + codec.DefaultRegistry.Register("JavaActions$MicroflowParameterType", func() element.Element { + return initMicroflowParameterType() + }) + codec.DefaultRegistry.Register("JavaActions$ParameterizedEntityType", func() element.Element { + return initParameterizedEntityType() + }) + codec.DefaultRegistry.Register("JavaActions$StringType", func() element.Element { + return initStringType() + }) + codec.DefaultRegistry.Register("JavaActions$TypeParameter", func() element.Element { + return initTypeParameter() + }) +} diff --git a/modelsdk/gen/javaactions/version.go b/modelsdk/gen/javaactions/version.go new file mode 100644 index 00000000..5b04c4eb --- /dev/null +++ b/modelsdk/gen/javaactions/version.go @@ -0,0 +1,70 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package javaactions + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "JavaActions$BasicParameterType": { + Properties: map[string]version.PropertyVersionInfo{ + "type": {Required: true, Public: true}, + }, + }, + "JavaActions$ConcreteEntityType": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true, Public: true}, + }, + }, + "JavaActions$EntityTypeParameterType": { + Properties: map[string]version.PropertyVersionInfo{ + "typeParameter": {Public: true}, + }, + }, + "JavaActions$EnumerationType": { + Properties: map[string]version.PropertyVersionInfo{ + "enumeration": {Required: true, Public: true}, + }, + }, + "JavaActions$JavaAction": { + Properties: map[string]version.PropertyVersionInfo{ + "javaReturnType": {Introduced: "6.6.0", Deleted: "7.21.0", Required: true, Public: true}, + "microflowActionInfo": {Introduced: "6.6.0", Deleted: "7.21.0", Public: true}, + "parameters": {Deleted: "7.21.0", Public: true}, + "returnType": {Deleted: "6.6.0", Public: true}, + "typeParameters": {Introduced: "6.6.0", Deleted: "7.21.0", Public: true}, + "useLegacyCodeGeneration": {Introduced: "8.0.0", Deleted: "9.0.3", Public: true}, + }, + }, + "JavaActions$JavaActionParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "javaType": {Introduced: "6.6.0", Deleted: "6.7.0", Required: true, Public: true}, + "parameterType": {Introduced: "6.7.0", Deleted: "7.21.0", Required: true, Public: true}, + "type": {Deleted: "6.6.0", Public: true}, + }, + }, + "JavaActions$ListType": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true, Public: true}, + }, + }, + "JavaActions$MicroflowActionInfo": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Public: true}, + "category": {Public: true}, + "icon": {Public: true}, + }, + }, + "JavaActions$ParameterizedEntityType": { + Properties: map[string]version.PropertyVersionInfo{ + "typeParameter": {Required: true, Public: true}, + }, + }, + "JavaActions$TypeParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + }, + }, +} diff --git a/modelsdk/gen/javascriptactions/enums.go b/modelsdk/gen/javascriptactions/enums.go new file mode 100644 index 00000000..9dfff769 --- /dev/null +++ b/modelsdk/gen/javascriptactions/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package javascriptactions diff --git a/modelsdk/gen/javascriptactions/refs.go b/modelsdk/gen/javascriptactions/refs.go new file mode 100644 index 00000000..9dfff769 --- /dev/null +++ b/modelsdk/gen/javascriptactions/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package javascriptactions diff --git a/modelsdk/gen/javascriptactions/types.go b/modelsdk/gen/javascriptactions/types.go new file mode 100644 index 00000000..bc732639 --- /dev/null +++ b/modelsdk/gen/javascriptactions/types.go @@ -0,0 +1,405 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package javascriptactions + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// JavaScriptAction +// ──────────────────────────────────────────────────────── + +type JavaScriptAction struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + actionTypeParameters *property.PartList[element.Element] + actionReturnType *property.Part[element.Element] + actionDefaultReturnName *property.Primitive[string] + modelerActionInfo *property.Part[element.Element] + actionParameters *property.PartList[element.Element] + platform *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *JavaScriptAction) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *JavaScriptAction) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *JavaScriptAction) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *JavaScriptAction) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *JavaScriptAction) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *JavaScriptAction) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *JavaScriptAction) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *JavaScriptAction) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ActionTypeParametersItems returns the value of the actionTypeParameters property. +func (o *JavaScriptAction) ActionTypeParametersItems() []element.Element { + return o.actionTypeParameters.Items() +} + +// AddActionTypeParameters appends a child element to the actionTypeParameters list. +func (o *JavaScriptAction) AddActionTypeParameters(v element.Element) { + o.actionTypeParameters.Append(v) +} + +// RemoveActionTypeParameters removes the element at the given index from the actionTypeParameters list. +func (o *JavaScriptAction) RemoveActionTypeParameters(index int) { + o.actionTypeParameters.Remove(index) +} + +// ActionReturnType returns the value of the actionReturnType property. +func (o *JavaScriptAction) ActionReturnType() element.Element { + return o.actionReturnType.Get() +} + +// SetActionReturnType sets the value of the actionReturnType property. +func (o *JavaScriptAction) SetActionReturnType(v element.Element) { + o.actionReturnType.Set(v) +} + +// ActionDefaultReturnName returns the value of the actionDefaultReturnName property. +func (o *JavaScriptAction) ActionDefaultReturnName() string { + return o.actionDefaultReturnName.Get() +} + +// SetActionDefaultReturnName sets the value of the actionDefaultReturnName property. +func (o *JavaScriptAction) SetActionDefaultReturnName(v string) { + o.actionDefaultReturnName.Set(v) +} + +// ModelerActionInfo returns the value of the modelerActionInfo property. +func (o *JavaScriptAction) ModelerActionInfo() element.Element { + return o.modelerActionInfo.Get() +} + +// SetModelerActionInfo sets the value of the modelerActionInfo property. +func (o *JavaScriptAction) SetModelerActionInfo(v element.Element) { + o.modelerActionInfo.Set(v) +} + +// ActionParametersItems returns the value of the actionParameters property. +func (o *JavaScriptAction) ActionParametersItems() []element.Element { + return o.actionParameters.Items() +} + +// AddActionParameters appends a child element to the actionParameters list. +func (o *JavaScriptAction) AddActionParameters(v element.Element) { + o.actionParameters.Append(v) +} + +// RemoveActionParameters removes the element at the given index from the actionParameters list. +func (o *JavaScriptAction) RemoveActionParameters(index int) { + o.actionParameters.Remove(index) +} + +// Platform returns the value of the platform property. +func (o *JavaScriptAction) Platform() string { + return o.platform.Get() +} + +// SetPlatform sets the value of the platform property. +func (o *JavaScriptAction) SetPlatform(v string) { + o.platform.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaScriptAction) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "ActionTypeParameters"); err == nil { + for _, child := range children { + o.actionTypeParameters.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ActionReturnType"); err == nil { + o.actionReturnType.SetFromDecode(child) + } + o.actionDefaultReturnName.Init(raw) + if child, err := codec.DecodeChild(raw, "ModelerActionInfo"); err == nil { + o.modelerActionInfo.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "ActionParameters"); err == nil { + for _, child := range children { + o.actionParameters.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Platform"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.platform.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// JavaScriptActionParameter +// ──────────────────────────────────────────────────────── + +type JavaScriptActionParameter struct { + element.Base + name *property.Primitive[string] + actionParameterType *property.Part[element.Element] + description *property.Primitive[string] + category *property.Primitive[string] + isRequired *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *JavaScriptActionParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *JavaScriptActionParameter) SetName(v string) { + o.name.Set(v) +} + +// ActionParameterType returns the value of the actionParameterType property. +func (o *JavaScriptActionParameter) ActionParameterType() element.Element { + return o.actionParameterType.Get() +} + +// SetActionParameterType sets the value of the actionParameterType property. +func (o *JavaScriptActionParameter) SetActionParameterType(v element.Element) { + o.actionParameterType.Set(v) +} + +// Description returns the value of the description property. +func (o *JavaScriptActionParameter) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *JavaScriptActionParameter) SetDescription(v string) { + o.description.Set(v) +} + +// Category returns the value of the category property. +func (o *JavaScriptActionParameter) Category() string { + return o.category.Get() +} + +// SetCategory sets the value of the category property. +func (o *JavaScriptActionParameter) SetCategory(v string) { + o.category.Set(v) +} + +// IsRequired returns the value of the isRequired property. +func (o *JavaScriptActionParameter) IsRequired() bool { + return o.isRequired.Get() +} + +// SetIsRequired sets the value of the isRequired property. +func (o *JavaScriptActionParameter) SetIsRequired(v bool) { + o.isRequired.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaScriptActionParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "ActionParameterType"); err == nil { + o.actionParameterType.SetFromDecode(child) + } + o.description.Init(raw) + o.category.Init(raw) + o.isRequired.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MicroflowJavaScriptActionParameterType +// ──────────────────────────────────────────────────────── + +type MicroflowJavaScriptActionParameterType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowJavaScriptActionParameterType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// NanoflowJavaScriptActionParameterType +// ──────────────────────────────────────────────────────── + +type NanoflowJavaScriptActionParameterType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NanoflowJavaScriptActionParameterType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initJavaScriptAction creates a JavaScriptAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJavaScriptAction() *JavaScriptAction { + o := &JavaScriptAction{} + o.SetTypeName("JavaScriptActions$JavaScriptAction") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.actionTypeParameters = property.NewPartList[element.Element]("ActionTypeParameters") + o.actionTypeParameters.Bind(&o.Base, 4) + o.actionReturnType = property.NewPart[element.Element]("ActionReturnType") + o.actionReturnType.Bind(&o.Base, 5) + o.actionDefaultReturnName = property.NewPrimitive[string]("ActionDefaultReturnName", property.DecodeString) + o.actionDefaultReturnName.Bind(&o.Base, 6) + o.modelerActionInfo = property.NewPart[element.Element]("ModelerActionInfo") + o.modelerActionInfo.Bind(&o.Base, 7) + o.actionParameters = property.NewPartList[element.Element]("ActionParameters") + o.actionParameters.Bind(&o.Base, 8) + o.platform = property.NewEnum[string]("Platform") + o.platform.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.actionTypeParameters, o.actionReturnType, o.actionDefaultReturnName, o.modelerActionInfo, o.actionParameters, o.platform}) + return o +} + +// NewJavaScriptAction creates a new JavaScriptAction for user code. Marked dirty (bit 63 = new element). +func NewJavaScriptAction() *JavaScriptAction { + o := initJavaScriptAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJavaScriptActionParameter creates a JavaScriptActionParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJavaScriptActionParameter() *JavaScriptActionParameter { + o := &JavaScriptActionParameter{} + o.SetTypeName("JavaScriptActions$JavaScriptActionParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.actionParameterType = property.NewPart[element.Element]("ActionParameterType") + o.actionParameterType.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.category = property.NewPrimitive[string]("Category", property.DecodeString) + o.category.Bind(&o.Base, 3) + o.isRequired = property.NewPrimitive[bool]("IsRequired", property.DecodeBool) + o.isRequired.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.actionParameterType, o.description, o.category, o.isRequired}) + return o +} + +// NewJavaScriptActionParameter creates a new JavaScriptActionParameter for user code. Marked dirty (bit 63 = new element). +func NewJavaScriptActionParameter() *JavaScriptActionParameter { + o := initJavaScriptActionParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowJavaScriptActionParameterType creates a MicroflowJavaScriptActionParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowJavaScriptActionParameterType() *MicroflowJavaScriptActionParameterType { + o := &MicroflowJavaScriptActionParameterType{} + o.SetTypeName("JavaScriptActions$MicroflowJavaScriptActionParameterType") + o.SetProperties([]element.Property{}) + return o +} + +// NewMicroflowJavaScriptActionParameterType creates a new MicroflowJavaScriptActionParameterType for user code. Marked dirty (bit 63 = new element). +func NewMicroflowJavaScriptActionParameterType() *MicroflowJavaScriptActionParameterType { + o := initMicroflowJavaScriptActionParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNanoflowJavaScriptActionParameterType creates a NanoflowJavaScriptActionParameterType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNanoflowJavaScriptActionParameterType() *NanoflowJavaScriptActionParameterType { + o := &NanoflowJavaScriptActionParameterType{} + o.SetTypeName("JavaScriptActions$NanoflowJavaScriptActionParameterType") + o.SetProperties([]element.Property{}) + return o +} + +// NewNanoflowJavaScriptActionParameterType creates a new NanoflowJavaScriptActionParameterType for user code. Marked dirty (bit 63 = new element). +func NewNanoflowJavaScriptActionParameterType() *NanoflowJavaScriptActionParameterType { + o := initNanoflowJavaScriptActionParameterType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("JavaScriptActions$JavaScriptAction", func() element.Element { + return initJavaScriptAction() + }) + codec.DefaultRegistry.Register("JavaScriptActions$JavaScriptActionParameter", func() element.Element { + return initJavaScriptActionParameter() + }) + codec.DefaultRegistry.Register("JavaScriptActions$MicroflowJavaScriptActionParameterType", func() element.Element { + return initMicroflowJavaScriptActionParameterType() + }) + codec.DefaultRegistry.Register("JavaScriptActions$NanoflowJavaScriptActionParameterType", func() element.Element { + return initNanoflowJavaScriptActionParameterType() + }) +} diff --git a/modelsdk/gen/javascriptactions/version.go b/modelsdk/gen/javascriptactions/version.go new file mode 100644 index 00000000..7285c786 --- /dev/null +++ b/modelsdk/gen/javascriptactions/version.go @@ -0,0 +1,16 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package javascriptactions + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "JavaScriptActions$JavaScriptAction": { + Properties: map[string]version.PropertyVersionInfo{ + "platform": {Introduced: "9.10.0", Public: true}, + }, + }, +} diff --git a/modelsdk/gen/jsonstructures/enums.go b/modelsdk/gen/jsonstructures/enums.go new file mode 100644 index 00000000..c9c5fcec --- /dev/null +++ b/modelsdk/gen/jsonstructures/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package jsonstructures diff --git a/modelsdk/gen/jsonstructures/refs.go b/modelsdk/gen/jsonstructures/refs.go new file mode 100644 index 00000000..c9c5fcec --- /dev/null +++ b/modelsdk/gen/jsonstructures/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package jsonstructures diff --git a/modelsdk/gen/jsonstructures/types.go b/modelsdk/gen/jsonstructures/types.go new file mode 100644 index 00000000..c4d9e945 --- /dev/null +++ b/modelsdk/gen/jsonstructures/types.go @@ -0,0 +1,433 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package jsonstructures + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// JsonElement +// ──────────────────────────────────────────────────────── + +type JsonElement struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] + originalValue *property.Primitive[string] +} + +// ElementType returns the value of the elementType property. +func (o *JsonElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *JsonElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *JsonElement) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *JsonElement) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *JsonElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *JsonElement) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *JsonElement) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *JsonElement) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *JsonElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *JsonElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *JsonElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *JsonElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *JsonElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *JsonElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *JsonElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *JsonElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *JsonElement) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *JsonElement) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *JsonElement) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *JsonElement) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *JsonElement) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *JsonElement) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *JsonElement) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *JsonElement) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *JsonElement) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *JsonElement) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *JsonElement) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *JsonElement) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *JsonElement) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *JsonElement) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *JsonElement) RemoveChildren(index int) { + o.children.Remove(index) +} + +// OriginalValue returns the value of the originalValue property. +func (o *JsonElement) OriginalValue() string { + return o.originalValue.Get() +} + +// SetOriginalValue sets the value of the originalValue property. +func (o *JsonElement) SetOriginalValue(v string) { + o.originalValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JsonElement) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } + o.originalValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// JsonStructure +// ──────────────────────────────────────────────────────── + +type JsonStructure struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + jsonSnippet *property.Primitive[string] + elements *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *JsonStructure) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *JsonStructure) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *JsonStructure) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *JsonStructure) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *JsonStructure) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *JsonStructure) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *JsonStructure) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *JsonStructure) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// JsonSnippet returns the value of the jsonSnippet property. +func (o *JsonStructure) JsonSnippet() string { + return o.jsonSnippet.Get() +} + +// SetJsonSnippet sets the value of the jsonSnippet property. +func (o *JsonStructure) SetJsonSnippet(v string) { + o.jsonSnippet.Set(v) +} + +// ElementsItems returns the value of the elements property. +func (o *JsonStructure) ElementsItems() []element.Element { + return o.elements.Items() +} + +// AddElements appends a child element to the elements list. +func (o *JsonStructure) AddElements(v element.Element) { + o.elements.Append(v) +} + +// RemoveElements removes the element at the given index from the elements list. +func (o *JsonStructure) RemoveElements(index int) { + o.elements.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JsonStructure) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.jsonSnippet.Init(raw) + if children, err := codec.DecodeChildren(raw, "Elements"); err == nil { + for _, child := range children { + o.elements.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initJsonElement creates a JsonElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJsonElement() *JsonElement { + o := &JsonElement{} + o.SetTypeName("JsonStructures$JsonElement") + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 0) + o.primitiveType = property.NewEnum[string]("PrimitiveType") + o.primitiveType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 3) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 4) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 5) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 6) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 7) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 8) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 9) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 10) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 11) + o.errorMessage = property.NewPrimitive[string]("ErrorMessage", property.DecodeString) + o.errorMessage.Bind(&o.Base, 12) + o.warningMessage = property.NewPrimitive[string]("WarningMessage", property.DecodeString) + o.warningMessage.Bind(&o.Base, 13) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 14) + o.originalValue = property.NewPrimitive[string]("OriginalValue", property.DecodeString) + o.originalValue.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.elementType, o.primitiveType, o.path, o.isDefaultType, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.exposedItemName, o.maxLength, o.fractionDigits, o.totalDigits, o.errorMessage, o.warningMessage, o.children, o.originalValue}) + return o +} + +// NewJsonElement creates a new JsonElement for user code. Marked dirty (bit 63 = new element). +func NewJsonElement() *JsonElement { + o := initJsonElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJsonStructure creates a JsonStructure with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJsonStructure() *JsonStructure { + o := &JsonStructure{} + o.SetTypeName("JsonStructures$JsonStructure") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.jsonSnippet = property.NewPrimitive[string]("JsonSnippet", property.DecodeString) + o.jsonSnippet.Bind(&o.Base, 4) + o.elements = property.NewPartList[element.Element]("Elements") + o.elements.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.jsonSnippet, o.elements}) + return o +} + +// NewJsonStructure creates a new JsonStructure for user code. Marked dirty (bit 63 = new element). +func NewJsonStructure() *JsonStructure { + o := initJsonStructure() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("JsonStructures$JsonElement", func() element.Element { + return initJsonElement() + }) + codec.DefaultRegistry.Register("JsonStructures$JsonStructure", func() element.Element { + return initJsonStructure() + }) +} diff --git a/modelsdk/gen/jsonstructures/version.go b/modelsdk/gen/jsonstructures/version.go new file mode 100644 index 00000000..77b5a210 --- /dev/null +++ b/modelsdk/gen/jsonstructures/version.go @@ -0,0 +1,16 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package jsonstructures + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "JsonStructures$JsonStructure": { + Properties: map[string]version.PropertyVersionInfo{ + "elements": {Introduced: "6.6.0"}, + }, + }, +} diff --git a/modelsdk/gen/kafka/enums.go b/modelsdk/gen/kafka/enums.go new file mode 100644 index 00000000..dd377f0b --- /dev/null +++ b/modelsdk/gen/kafka/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package kafka diff --git a/modelsdk/gen/kafka/refs.go b/modelsdk/gen/kafka/refs.go new file mode 100644 index 00000000..8c2810ef --- /dev/null +++ b/modelsdk/gen/kafka/refs.go @@ -0,0 +1,29 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package kafka + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Kafka$ConsumedKafkaService", []codec.RefMeta{ + {Prop: "BrokerUrl", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "BrokerUsername", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "BrokerPassword", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Kafka$KafkaRemoteEntitySource", []codec.RefMeta{ + {Prop: "SourceDocument", Kind: codec.RefByName, Target: "Kafka$ConsumedKafkaService"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Kafka$PublishedKafkaResource", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Kafka$PublishedKafkaResourceAttribute", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Kafka$PublishedKafkaService", []codec.RefMeta{ + {Prop: "BrokerUrl", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "BrokerUsername", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "BrokerPassword", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) +} diff --git a/modelsdk/gen/kafka/types.go b/modelsdk/gen/kafka/types.go new file mode 100644 index 00000000..44377af5 --- /dev/null +++ b/modelsdk/gen/kafka/types.go @@ -0,0 +1,1071 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package kafka + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// ConsumedKafkaService +// ──────────────────────────────────────────────────────── + +type ConsumedKafkaService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + description *property.Primitive[string] + catalogUrl *property.Primitive[string] + icon *property.Primitive[string] + metadata *property.Primitive[string] + metadataUrl *property.Primitive[string] + serviceName *property.Primitive[string] + version *property.Primitive[string] + endpointId *property.Primitive[string] + minimumMxVersion *property.Primitive[string] + recommendedMxVersion *property.Primitive[string] + applicationId *property.Primitive[string] + environmentType *property.Enum[string] + metadataHash *property.Primitive[string] + validated *property.Primitive[bool] + validatedEntities *property.Primitive[string] + metadataReferences *property.PartList[element.Element] + serviceId *property.Primitive[string] + serviceFeed *property.Primitive[string] + brokerUrl *property.ByNameRef[element.Element] + brokerUsername *property.ByNameRef[element.Element] + brokerPassword *property.ByNameRef[element.Element] +} + +// Name returns the value of the name property. +func (o *ConsumedKafkaService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConsumedKafkaService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ConsumedKafkaService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ConsumedKafkaService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ConsumedKafkaService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ConsumedKafkaService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ConsumedKafkaService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ConsumedKafkaService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Description returns the value of the description property. +func (o *ConsumedKafkaService) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *ConsumedKafkaService) SetDescription(v string) { + o.description.Set(v) +} + +// CatalogUrl returns the value of the catalogUrl property. +func (o *ConsumedKafkaService) CatalogUrl() string { + return o.catalogUrl.Get() +} + +// SetCatalogUrl sets the value of the catalogUrl property. +func (o *ConsumedKafkaService) SetCatalogUrl(v string) { + o.catalogUrl.Set(v) +} + +// Icon returns the value of the icon property. +func (o *ConsumedKafkaService) Icon() string { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *ConsumedKafkaService) SetIcon(v string) { + o.icon.Set(v) +} + +// Metadata returns the value of the metadata property. +func (o *ConsumedKafkaService) Metadata() string { + return o.metadata.Get() +} + +// SetMetadata sets the value of the metadata property. +func (o *ConsumedKafkaService) SetMetadata(v string) { + o.metadata.Set(v) +} + +// MetadataUrl returns the value of the metadataUrl property. +func (o *ConsumedKafkaService) MetadataUrl() string { + return o.metadataUrl.Get() +} + +// SetMetadataUrl sets the value of the metadataUrl property. +func (o *ConsumedKafkaService) SetMetadataUrl(v string) { + o.metadataUrl.Set(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *ConsumedKafkaService) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *ConsumedKafkaService) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// Version returns the value of the version property. +func (o *ConsumedKafkaService) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *ConsumedKafkaService) SetVersion(v string) { + o.version.Set(v) +} + +// EndpointId returns the value of the endpointId property. +func (o *ConsumedKafkaService) EndpointId() string { + return o.endpointId.Get() +} + +// SetEndpointId sets the value of the endpointId property. +func (o *ConsumedKafkaService) SetEndpointId(v string) { + o.endpointId.Set(v) +} + +// MinimumMxVersion returns the value of the minimumMxVersion property. +func (o *ConsumedKafkaService) MinimumMxVersion() string { + return o.minimumMxVersion.Get() +} + +// SetMinimumMxVersion sets the value of the minimumMxVersion property. +func (o *ConsumedKafkaService) SetMinimumMxVersion(v string) { + o.minimumMxVersion.Set(v) +} + +// RecommendedMxVersion returns the value of the recommendedMxVersion property. +func (o *ConsumedKafkaService) RecommendedMxVersion() string { + return o.recommendedMxVersion.Get() +} + +// SetRecommendedMxVersion sets the value of the recommendedMxVersion property. +func (o *ConsumedKafkaService) SetRecommendedMxVersion(v string) { + o.recommendedMxVersion.Set(v) +} + +// ApplicationId returns the value of the applicationId property. +func (o *ConsumedKafkaService) ApplicationId() string { + return o.applicationId.Get() +} + +// SetApplicationId sets the value of the applicationId property. +func (o *ConsumedKafkaService) SetApplicationId(v string) { + o.applicationId.Set(v) +} + +// EnvironmentType returns the value of the environmentType property. +func (o *ConsumedKafkaService) EnvironmentType() string { + return o.environmentType.Get() +} + +// SetEnvironmentType sets the value of the environmentType property. +func (o *ConsumedKafkaService) SetEnvironmentType(v string) { + o.environmentType.Set(v) +} + +// MetadataHash returns the value of the metadataHash property. +func (o *ConsumedKafkaService) MetadataHash() string { + return o.metadataHash.Get() +} + +// SetMetadataHash sets the value of the metadataHash property. +func (o *ConsumedKafkaService) SetMetadataHash(v string) { + o.metadataHash.Set(v) +} + +// Validated returns the value of the validated property. +func (o *ConsumedKafkaService) Validated() bool { + return o.validated.Get() +} + +// SetValidated sets the value of the validated property. +func (o *ConsumedKafkaService) SetValidated(v bool) { + o.validated.Set(v) +} + +// ValidatedEntities returns the value of the validatedEntities property. +func (o *ConsumedKafkaService) ValidatedEntities() string { + return o.validatedEntities.Get() +} + +// MetadataReferencesItems returns the value of the metadataReferences property. +func (o *ConsumedKafkaService) MetadataReferencesItems() []element.Element { + return o.metadataReferences.Items() +} + +// AddMetadataReferences appends a child element to the metadataReferences list. +func (o *ConsumedKafkaService) AddMetadataReferences(v element.Element) { + o.metadataReferences.Append(v) +} + +// RemoveMetadataReferences removes the element at the given index from the metadataReferences list. +func (o *ConsumedKafkaService) RemoveMetadataReferences(index int) { + o.metadataReferences.Remove(index) +} + +// ServiceId returns the value of the serviceId property. +func (o *ConsumedKafkaService) ServiceId() string { + return o.serviceId.Get() +} + +// SetServiceId sets the value of the serviceId property. +func (o *ConsumedKafkaService) SetServiceId(v string) { + o.serviceId.Set(v) +} + +// ServiceFeed returns the value of the serviceFeed property. +func (o *ConsumedKafkaService) ServiceFeed() string { + return o.serviceFeed.Get() +} + +// SetServiceFeed sets the value of the serviceFeed property. +func (o *ConsumedKafkaService) SetServiceFeed(v string) { + o.serviceFeed.Set(v) +} + +// BrokerUrlQualifiedName returns the value of the brokerUrl property. +func (o *ConsumedKafkaService) BrokerUrlQualifiedName() string { + return o.brokerUrl.QualifiedName() +} + +// SetBrokerUrlQualifiedName sets the value of the brokerUrl property. +func (o *ConsumedKafkaService) SetBrokerUrlQualifiedName(v string) { + o.brokerUrl.SetQualifiedName(v) +} + +// BrokerUsernameQualifiedName returns the value of the brokerUsername property. +func (o *ConsumedKafkaService) BrokerUsernameQualifiedName() string { + return o.brokerUsername.QualifiedName() +} + +// SetBrokerUsernameQualifiedName sets the value of the brokerUsername property. +func (o *ConsumedKafkaService) SetBrokerUsernameQualifiedName(v string) { + o.brokerUsername.SetQualifiedName(v) +} + +// BrokerPasswordQualifiedName returns the value of the brokerPassword property. +func (o *ConsumedKafkaService) BrokerPasswordQualifiedName() string { + return o.brokerPassword.QualifiedName() +} + +// SetBrokerPasswordQualifiedName sets the value of the brokerPassword property. +func (o *ConsumedKafkaService) SetBrokerPasswordQualifiedName(v string) { + o.brokerPassword.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConsumedKafkaService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.description.Init(raw) + o.catalogUrl.Init(raw) + o.icon.Init(raw) + o.metadata.Init(raw) + o.metadataUrl.Init(raw) + o.serviceName.Init(raw) + o.version.Init(raw) + o.endpointId.Init(raw) + o.minimumMxVersion.Init(raw) + o.recommendedMxVersion.Init(raw) + o.applicationId.Init(raw) + if val, err := raw.LookupErr("EnvironmentType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.environmentType.SetFromDecode(s) + } + } + o.metadataHash.Init(raw) + o.validated.Init(raw) + o.validatedEntities.Init(raw) + if children, err := codec.DecodeChildren(raw, "MetadataReferences"); err == nil { + for _, child := range children { + o.metadataReferences.AppendFromDecode(child) + } + } + o.serviceId.Init(raw) + o.serviceFeed.Init(raw) + if val, err := raw.LookupErr("BrokerUrl"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.brokerUrl.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("BrokerUsername"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.brokerUsername.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("BrokerPassword"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.brokerPassword.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// KafkaMappedValue +// ──────────────────────────────────────────────────────── + +type KafkaMappedValue struct { + element.Base + defaultValueDesignTime *property.Primitive[string] + remoteName *property.Primitive[string] +} + +// DefaultValueDesignTime returns the value of the defaultValueDesignTime property. +func (o *KafkaMappedValue) DefaultValueDesignTime() string { + return o.defaultValueDesignTime.Get() +} + +// SetDefaultValueDesignTime sets the value of the defaultValueDesignTime property. +func (o *KafkaMappedValue) SetDefaultValueDesignTime(v string) { + o.defaultValueDesignTime.Set(v) +} + +// RemoteName returns the value of the remoteName property. +func (o *KafkaMappedValue) RemoteName() string { + return o.remoteName.Get() +} + +// SetRemoteName sets the value of the remoteName property. +func (o *KafkaMappedValue) SetRemoteName(v string) { + o.remoteName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *KafkaMappedValue) InitFromRaw(raw bson.Raw) { + o.defaultValueDesignTime.Init(raw) + o.remoteName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// KafkaRemoteEntitySource +// ──────────────────────────────────────────────────────── + +type KafkaRemoteEntitySource struct { + element.Base + sourceDocument *property.ByNameRef[element.Element] + remoteName *property.Primitive[string] + topicName *property.Primitive[string] +} + +// SourceDocumentQualifiedName returns the value of the sourceDocument property. +func (o *KafkaRemoteEntitySource) SourceDocumentQualifiedName() string { + return o.sourceDocument.QualifiedName() +} + +// SetSourceDocumentQualifiedName sets the value of the sourceDocument property. +func (o *KafkaRemoteEntitySource) SetSourceDocumentQualifiedName(v string) { + o.sourceDocument.SetQualifiedName(v) +} + +// RemoteName returns the value of the remoteName property. +func (o *KafkaRemoteEntitySource) RemoteName() string { + return o.remoteName.Get() +} + +// SetRemoteName sets the value of the remoteName property. +func (o *KafkaRemoteEntitySource) SetRemoteName(v string) { + o.remoteName.Set(v) +} + +// TopicName returns the value of the topicName property. +func (o *KafkaRemoteEntitySource) TopicName() string { + return o.topicName.Get() +} + +// SetTopicName sets the value of the topicName property. +func (o *KafkaRemoteEntitySource) SetTopicName(v string) { + o.topicName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *KafkaRemoteEntitySource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("SourceDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.sourceDocument.SetFromDecode(s) + } + } + o.remoteName.Init(raw) + o.topicName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedKafkaResource +// ──────────────────────────────────────────────────────── + +type PublishedKafkaResource struct { + element.Base + entity *property.ByNameRef[element.Element] + exposedName *property.Primitive[string] + topicName *property.Primitive[string] + attributes *property.PartList[element.Element] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *PublishedKafkaResource) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *PublishedKafkaResource) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedKafkaResource) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedKafkaResource) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// TopicName returns the value of the topicName property. +func (o *PublishedKafkaResource) TopicName() string { + return o.topicName.Get() +} + +// SetTopicName sets the value of the topicName property. +func (o *PublishedKafkaResource) SetTopicName(v string) { + o.topicName.Set(v) +} + +// AttributesItems returns the value of the attributes property. +func (o *PublishedKafkaResource) AttributesItems() []element.Element { + return o.attributes.Items() +} + +// AddAttributes appends a child element to the attributes list. +func (o *PublishedKafkaResource) AddAttributes(v element.Element) { + o.attributes.Append(v) +} + +// RemoveAttributes removes the element at the given index from the attributes list. +func (o *PublishedKafkaResource) RemoveAttributes(index int) { + o.attributes.Remove(index) +} + +// Summary returns the value of the summary property. +func (o *PublishedKafkaResource) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedKafkaResource) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedKafkaResource) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedKafkaResource) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedKafkaResource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + o.exposedName.Init(raw) + o.topicName.Init(raw) + if children, err := codec.DecodeChildren(raw, "Attributes"); err == nil { + for _, child := range children { + o.attributes.AppendFromDecode(child) + } + } + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedKafkaResourceAttribute +// ──────────────────────────────────────────────────────── + +type PublishedKafkaResourceAttribute struct { + element.Base + attribute *property.ByNameRef[element.Element] + exposedName *property.Primitive[string] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *PublishedKafkaResourceAttribute) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *PublishedKafkaResourceAttribute) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedKafkaResourceAttribute) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedKafkaResourceAttribute) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedKafkaResourceAttribute) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedKafkaResourceAttribute) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedKafkaResourceAttribute) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedKafkaResourceAttribute) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedKafkaResourceAttribute) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } + o.exposedName.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedKafkaService +// ──────────────────────────────────────────────────────── + +type PublishedKafkaService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + namespace *property.Primitive[string] + serviceFeed *property.Primitive[string] + metadata *property.Primitive[string] + serviceName *property.Primitive[string] + resources *property.PartList[element.Element] + version *property.Primitive[string] + summary *property.Primitive[string] + description *property.Primitive[string] + brokerUrl *property.ByNameRef[element.Element] + brokerUsername *property.ByNameRef[element.Element] + brokerPassword *property.ByNameRef[element.Element] +} + +// Name returns the value of the name property. +func (o *PublishedKafkaService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedKafkaService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedKafkaService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedKafkaService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *PublishedKafkaService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *PublishedKafkaService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *PublishedKafkaService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *PublishedKafkaService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Namespace returns the value of the namespace property. +func (o *PublishedKafkaService) Namespace() string { + return o.namespace.Get() +} + +// SetNamespace sets the value of the namespace property. +func (o *PublishedKafkaService) SetNamespace(v string) { + o.namespace.Set(v) +} + +// ServiceFeed returns the value of the serviceFeed property. +func (o *PublishedKafkaService) ServiceFeed() string { + return o.serviceFeed.Get() +} + +// SetServiceFeed sets the value of the serviceFeed property. +func (o *PublishedKafkaService) SetServiceFeed(v string) { + o.serviceFeed.Set(v) +} + +// Metadata returns the value of the metadata property. +func (o *PublishedKafkaService) Metadata() string { + return o.metadata.Get() +} + +// SetMetadata sets the value of the metadata property. +func (o *PublishedKafkaService) SetMetadata(v string) { + o.metadata.Set(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *PublishedKafkaService) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *PublishedKafkaService) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// ResourcesItems returns the value of the resources property. +func (o *PublishedKafkaService) ResourcesItems() []element.Element { + return o.resources.Items() +} + +// AddResources appends a child element to the resources list. +func (o *PublishedKafkaService) AddResources(v element.Element) { + o.resources.Append(v) +} + +// RemoveResources removes the element at the given index from the resources list. +func (o *PublishedKafkaService) RemoveResources(index int) { + o.resources.Remove(index) +} + +// Version returns the value of the version property. +func (o *PublishedKafkaService) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *PublishedKafkaService) SetVersion(v string) { + o.version.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedKafkaService) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedKafkaService) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedKafkaService) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedKafkaService) SetDescription(v string) { + o.description.Set(v) +} + +// BrokerUrlQualifiedName returns the value of the brokerUrl property. +func (o *PublishedKafkaService) BrokerUrlQualifiedName() string { + return o.brokerUrl.QualifiedName() +} + +// SetBrokerUrlQualifiedName sets the value of the brokerUrl property. +func (o *PublishedKafkaService) SetBrokerUrlQualifiedName(v string) { + o.brokerUrl.SetQualifiedName(v) +} + +// BrokerUsernameQualifiedName returns the value of the brokerUsername property. +func (o *PublishedKafkaService) BrokerUsernameQualifiedName() string { + return o.brokerUsername.QualifiedName() +} + +// SetBrokerUsernameQualifiedName sets the value of the brokerUsername property. +func (o *PublishedKafkaService) SetBrokerUsernameQualifiedName(v string) { + o.brokerUsername.SetQualifiedName(v) +} + +// BrokerPasswordQualifiedName returns the value of the brokerPassword property. +func (o *PublishedKafkaService) BrokerPasswordQualifiedName() string { + return o.brokerPassword.QualifiedName() +} + +// SetBrokerPasswordQualifiedName sets the value of the brokerPassword property. +func (o *PublishedKafkaService) SetBrokerPasswordQualifiedName(v string) { + o.brokerPassword.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedKafkaService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.namespace.Init(raw) + o.serviceFeed.Init(raw) + o.metadata.Init(raw) + o.serviceName.Init(raw) + if children, err := codec.DecodeChildren(raw, "Resources"); err == nil { + for _, child := range children { + o.resources.AppendFromDecode(child) + } + } + o.version.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) + if val, err := raw.LookupErr("BrokerUrl"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.brokerUrl.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("BrokerUsername"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.brokerUsername.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("BrokerPassword"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.brokerPassword.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initConsumedKafkaService creates a ConsumedKafkaService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConsumedKafkaService() *ConsumedKafkaService { + o := &ConsumedKafkaService{} + o.SetTypeName("Kafka$ConsumedKafkaService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 4) + o.catalogUrl = property.NewPrimitive[string]("CatalogUrl", property.DecodeString) + o.catalogUrl.Bind(&o.Base, 5) + o.icon = property.NewPrimitive[string]("Icon", property.DecodeString) + o.icon.Bind(&o.Base, 6) + o.metadata = property.NewPrimitive[string]("Metadata", property.DecodeString) + o.metadata.Bind(&o.Base, 7) + o.metadataUrl = property.NewPrimitive[string]("MetadataUrl", property.DecodeString) + o.metadataUrl.Bind(&o.Base, 8) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 9) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 10) + o.endpointId = property.NewPrimitive[string]("EndpointId", property.DecodeString) + o.endpointId.Bind(&o.Base, 11) + o.minimumMxVersion = property.NewPrimitive[string]("MinimumMxVersion", property.DecodeString) + o.minimumMxVersion.Bind(&o.Base, 12) + o.recommendedMxVersion = property.NewPrimitive[string]("RecommendedMxVersion", property.DecodeString) + o.recommendedMxVersion.Bind(&o.Base, 13) + o.applicationId = property.NewPrimitive[string]("ApplicationId", property.DecodeString) + o.applicationId.Bind(&o.Base, 14) + o.environmentType = property.NewEnum[string]("EnvironmentType") + o.environmentType.Bind(&o.Base, 15) + o.metadataHash = property.NewPrimitive[string]("MetadataHash", property.DecodeString) + o.metadataHash.Bind(&o.Base, 16) + o.validated = property.NewPrimitive[bool]("Validated", property.DecodeBool) + o.validated.Bind(&o.Base, 17) + o.validatedEntities = property.NewPrimitive[string]("ValidatedEntities", property.DecodeString) + o.validatedEntities.Bind(&o.Base, 18) + o.metadataReferences = property.NewPartList[element.Element]("MetadataReferences") + o.metadataReferences.Bind(&o.Base, 19) + o.serviceId = property.NewPrimitive[string]("ServiceId", property.DecodeString) + o.serviceId.Bind(&o.Base, 20) + o.serviceFeed = property.NewPrimitive[string]("ServiceFeed", property.DecodeString) + o.serviceFeed.Bind(&o.Base, 21) + o.brokerUrl = property.NewByNameRef[element.Element]("BrokerUrl", "Constants$Constant") + o.brokerUrl.Bind(&o.Base, 22) + o.brokerUsername = property.NewByNameRef[element.Element]("BrokerUsername", "Constants$Constant") + o.brokerUsername.Bind(&o.Base, 23) + o.brokerPassword = property.NewByNameRef[element.Element]("BrokerPassword", "Constants$Constant") + o.brokerPassword.Bind(&o.Base, 24) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.description, o.catalogUrl, o.icon, o.metadata, o.metadataUrl, o.serviceName, o.version, o.endpointId, o.minimumMxVersion, o.recommendedMxVersion, o.applicationId, o.environmentType, o.metadataHash, o.validated, o.validatedEntities, o.metadataReferences, o.serviceId, o.serviceFeed, o.brokerUrl, o.brokerUsername, o.brokerPassword}) + return o +} + +// NewConsumedKafkaService creates a new ConsumedKafkaService for user code. Marked dirty (bit 63 = new element). +func NewConsumedKafkaService() *ConsumedKafkaService { + o := initConsumedKafkaService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initKafkaMappedValue creates a KafkaMappedValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initKafkaMappedValue() *KafkaMappedValue { + o := &KafkaMappedValue{} + o.SetTypeName("Kafka$KafkaMappedValue") + o.defaultValueDesignTime = property.NewPrimitive[string]("DefaultValueDesignTime", property.DecodeString) + o.defaultValueDesignTime.Bind(&o.Base, 0) + o.remoteName = property.NewPrimitive[string]("RemoteName", property.DecodeString) + o.remoteName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.defaultValueDesignTime, o.remoteName}) + return o +} + +// NewKafkaMappedValue creates a new KafkaMappedValue for user code. Marked dirty (bit 63 = new element). +func NewKafkaMappedValue() *KafkaMappedValue { + o := initKafkaMappedValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initKafkaRemoteEntitySource creates a KafkaRemoteEntitySource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initKafkaRemoteEntitySource() *KafkaRemoteEntitySource { + o := &KafkaRemoteEntitySource{} + o.SetTypeName("Kafka$KafkaRemoteEntitySource") + o.sourceDocument = property.NewByNameRef[element.Element]("SourceDocument", "Kafka$ConsumedKafkaService") + o.sourceDocument.Bind(&o.Base, 0) + o.remoteName = property.NewPrimitive[string]("RemoteName", property.DecodeString) + o.remoteName.Bind(&o.Base, 1) + o.topicName = property.NewPrimitive[string]("TopicName", property.DecodeString) + o.topicName.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.sourceDocument, o.remoteName, o.topicName}) + return o +} + +// NewKafkaRemoteEntitySource creates a new KafkaRemoteEntitySource for user code. Marked dirty (bit 63 = new element). +func NewKafkaRemoteEntitySource() *KafkaRemoteEntitySource { + o := initKafkaRemoteEntitySource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedKafkaResource creates a PublishedKafkaResource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedKafkaResource() *PublishedKafkaResource { + o := &PublishedKafkaResource{} + o.SetTypeName("Kafka$PublishedKafkaResource") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 1) + o.topicName = property.NewPrimitive[string]("TopicName", property.DecodeString) + o.topicName.Bind(&o.Base, 2) + o.attributes = property.NewPartList[element.Element]("Attributes") + o.attributes.Bind(&o.Base, 3) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 4) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.entity, o.exposedName, o.topicName, o.attributes, o.summary, o.description}) + return o +} + +// NewPublishedKafkaResource creates a new PublishedKafkaResource for user code. Marked dirty (bit 63 = new element). +func NewPublishedKafkaResource() *PublishedKafkaResource { + o := initPublishedKafkaResource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedKafkaResourceAttribute creates a PublishedKafkaResourceAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedKafkaResourceAttribute() *PublishedKafkaResourceAttribute { + o := &PublishedKafkaResourceAttribute{} + o.SetTypeName("Kafka$PublishedKafkaResourceAttribute") + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 0) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 1) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 2) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.attribute, o.exposedName, o.summary, o.description}) + return o +} + +// NewPublishedKafkaResourceAttribute creates a new PublishedKafkaResourceAttribute for user code. Marked dirty (bit 63 = new element). +func NewPublishedKafkaResourceAttribute() *PublishedKafkaResourceAttribute { + o := initPublishedKafkaResourceAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedKafkaService creates a PublishedKafkaService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedKafkaService() *PublishedKafkaService { + o := &PublishedKafkaService{} + o.SetTypeName("Kafka$PublishedKafkaService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.namespace = property.NewPrimitive[string]("Namespace", property.DecodeString) + o.namespace.Bind(&o.Base, 4) + o.serviceFeed = property.NewPrimitive[string]("ServiceFeed", property.DecodeString) + o.serviceFeed.Bind(&o.Base, 5) + o.metadata = property.NewPrimitive[string]("Metadata", property.DecodeString) + o.metadata.Bind(&o.Base, 6) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 7) + o.resources = property.NewPartList[element.Element]("Resources") + o.resources.Bind(&o.Base, 8) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 9) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 10) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 11) + o.brokerUrl = property.NewByNameRef[element.Element]("BrokerUrl", "Constants$Constant") + o.brokerUrl.Bind(&o.Base, 12) + o.brokerUsername = property.NewByNameRef[element.Element]("BrokerUsername", "Constants$Constant") + o.brokerUsername.Bind(&o.Base, 13) + o.brokerPassword = property.NewByNameRef[element.Element]("BrokerPassword", "Constants$Constant") + o.brokerPassword.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.namespace, o.serviceFeed, o.metadata, o.serviceName, o.resources, o.version, o.summary, o.description, o.brokerUrl, o.brokerUsername, o.brokerPassword}) + return o +} + +// NewPublishedKafkaService creates a new PublishedKafkaService for user code. Marked dirty (bit 63 = new element). +func NewPublishedKafkaService() *PublishedKafkaService { + o := initPublishedKafkaService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Kafka$ConsumedKafkaService", func() element.Element { + return initConsumedKafkaService() + }) + codec.DefaultRegistry.Register("Kafka$KafkaMappedValue", func() element.Element { + return initKafkaMappedValue() + }) + codec.DefaultRegistry.Register("Kafka$KafkaRemoteEntitySource", func() element.Element { + return initKafkaRemoteEntitySource() + }) + codec.DefaultRegistry.Register("Kafka$PublishedKafkaResource", func() element.Element { + return initPublishedKafkaResource() + }) + codec.DefaultRegistry.Register("Kafka$PublishedKafkaResourceAttribute", func() element.Element { + return initPublishedKafkaResourceAttribute() + }) + codec.DefaultRegistry.Register("Kafka$PublishedKafkaService", func() element.Element { + return initPublishedKafkaService() + }) +} diff --git a/modelsdk/gen/kafka/version.go b/modelsdk/gen/kafka/version.go new file mode 100644 index 00000000..1fb5b91d --- /dev/null +++ b/modelsdk/gen/kafka/version.go @@ -0,0 +1,40 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package kafka + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Kafka$ConsumedKafkaService": { + Properties: map[string]version.PropertyVersionInfo{ + "serviceFeed": {Introduced: "8.12.0"}, + "serviceId": {Deleted: "8.14.0"}, + }, + }, + "Kafka$KafkaRemoteEntitySource": { + Properties: map[string]version.PropertyVersionInfo{ + "topicName": {Introduced: "8.12.0"}, + }, + }, + "Kafka$PublishedKafkaResource": { + Properties: map[string]version.PropertyVersionInfo{ + "attributes": {Introduced: "9.0.1"}, + "entity": {Required: true}, + "topicName": {Deleted: "9.0.3"}, + }, + }, + "Kafka$PublishedKafkaResourceAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Required: true}, + "exposedName": {Introduced: "9.0.2"}, + }, + }, + "Kafka$PublishedKafkaService": { + Properties: map[string]version.PropertyVersionInfo{ + "brokerUrl": {}, + }, + }, +} diff --git a/modelsdk/gen/mappings/enums.go b/modelsdk/gen/mappings/enums.go new file mode 100644 index 00000000..28be5514 --- /dev/null +++ b/modelsdk/gen/mappings/enums.go @@ -0,0 +1,40 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package mappings + +// ElementType enumerates the possible values for the ElementType type. +type ElementType = string + +const ( + ElementTypeUndefined ElementType = "Undefined" + ElementTypeInheritance ElementType = "Inheritance" + ElementTypeChoice ElementType = "Choice" + ElementTypeObject ElementType = "Object" + ElementTypeValue ElementType = "Value" + ElementTypeSequence ElementType = "Sequence" + ElementTypeAll ElementType = "All" + ElementTypeNamedArray ElementType = "NamedArray" + ElementTypeArray ElementType = "Array" + ElementTypeWrapper ElementType = "Wrapper" +) + +// ObjectHandlingBackupEnum enumerates the possible values for the ObjectHandlingBackupEnum type. +type ObjectHandlingBackupEnum = string + +const ( + ObjectHandlingBackupEnumCreate ObjectHandlingBackupEnum = "Create" + ObjectHandlingBackupEnumIgnore ObjectHandlingBackupEnum = "Ignore" + ObjectHandlingBackupEnumError ObjectHandlingBackupEnum = "Error" +) + +// ObjectHandlingEnum enumerates the possible values for the ObjectHandlingEnum type. +type ObjectHandlingEnum = string + +const ( + ObjectHandlingEnumParameter ObjectHandlingEnum = "Parameter" + ObjectHandlingEnumCreate ObjectHandlingEnum = "Create" + ObjectHandlingEnumFind ObjectHandlingEnum = "Find" + ObjectHandlingEnumCustom ObjectHandlingEnum = "Custom" +) diff --git a/modelsdk/gen/mappings/refs.go b/modelsdk/gen/mappings/refs.go new file mode 100644 index 00000000..883fd2e2 --- /dev/null +++ b/modelsdk/gen/mappings/refs.go @@ -0,0 +1,33 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package mappings + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Mappings$MappingDocument", []codec.RefMeta{ + {Prop: "XmlSchema", Kind: codec.RefByName, Target: "XmlSchemas$XmlSchema"}, + {Prop: "JsonStructure", Kind: codec.RefByName, Target: "JsonStructures$JsonStructure"}, + {Prop: "ImportedWebService", Kind: codec.RefByName, Target: "WebServices$ImportedWebService"}, + {Prop: "MessageDefinition", Kind: codec.RefByName, Target: "MessageDefinitions$MessageDefinition"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Mappings$MappingMicroflowCall", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Mappings$MappingMicroflowCallImpl", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Mappings$MappingMicroflowParameter", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Mappings$ObjectMappingElement", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Mappings$ValueMappingElement", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Converter", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) +} diff --git a/modelsdk/gen/mappings/types.go b/modelsdk/gen/mappings/types.go new file mode 100644 index 00000000..3573fb66 --- /dev/null +++ b/modelsdk/gen/mappings/types.go @@ -0,0 +1,1400 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package mappings + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Element +// ──────────────────────────────────────────────────────── + +type Element struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] +} + +// ElementType returns the value of the elementType property. +func (o *Element) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *Element) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *Element) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *Element) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *Element) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *Element) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *Element) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *Element) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *Element) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *Element) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *Element) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *Element) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *Element) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *Element) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *Element) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *Element) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *Element) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *Element) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *Element) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *Element) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *Element) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *Element) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *Element) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *Element) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *Element) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *Element) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *Element) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *Element) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *Element) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *Element) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *Element) RemoveChildren(index int) { + o.children.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Element) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MappingDocument +// ──────────────────────────────────────────────────────── + +type MappingDocument struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + rootMappingElements *property.PartList[element.Element] + xmlSchema *property.ByNameRef[element.Element] + jsonStructure *property.ByNameRef[element.Element] + rootElementName *property.Primitive[string] + importedWebService *property.ByNameRef[element.Element] + serviceName *property.Primitive[string] + operationName *property.Primitive[string] + messageDefinition *property.ByNameRef[element.Element] + mappingSourceReference *property.Part[element.Element] + publicName *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *MappingDocument) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MappingDocument) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MappingDocument) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MappingDocument) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *MappingDocument) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *MappingDocument) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *MappingDocument) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *MappingDocument) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// RootMappingElementsItems returns the value of the rootMappingElements property. +func (o *MappingDocument) RootMappingElementsItems() []element.Element { + return o.rootMappingElements.Items() +} + +// AddRootMappingElements appends a child element to the rootMappingElements list. +func (o *MappingDocument) AddRootMappingElements(v element.Element) { + o.rootMappingElements.Append(v) +} + +// RemoveRootMappingElements removes the element at the given index from the rootMappingElements list. +func (o *MappingDocument) RemoveRootMappingElements(index int) { + o.rootMappingElements.Remove(index) +} + +// XmlSchemaQualifiedName returns the value of the xmlSchema property. +func (o *MappingDocument) XmlSchemaQualifiedName() string { + return o.xmlSchema.QualifiedName() +} + +// SetXmlSchemaQualifiedName sets the value of the xmlSchema property. +func (o *MappingDocument) SetXmlSchemaQualifiedName(v string) { + o.xmlSchema.SetQualifiedName(v) +} + +// JsonStructureQualifiedName returns the value of the jsonStructure property. +func (o *MappingDocument) JsonStructureQualifiedName() string { + return o.jsonStructure.QualifiedName() +} + +// SetJsonStructureQualifiedName sets the value of the jsonStructure property. +func (o *MappingDocument) SetJsonStructureQualifiedName(v string) { + o.jsonStructure.SetQualifiedName(v) +} + +// RootElementName returns the value of the rootElementName property. +func (o *MappingDocument) RootElementName() string { + return o.rootElementName.Get() +} + +// SetRootElementName sets the value of the rootElementName property. +func (o *MappingDocument) SetRootElementName(v string) { + o.rootElementName.Set(v) +} + +// ImportedWebServiceQualifiedName returns the value of the importedWebService property. +func (o *MappingDocument) ImportedWebServiceQualifiedName() string { + return o.importedWebService.QualifiedName() +} + +// SetImportedWebServiceQualifiedName sets the value of the importedWebService property. +func (o *MappingDocument) SetImportedWebServiceQualifiedName(v string) { + o.importedWebService.SetQualifiedName(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *MappingDocument) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *MappingDocument) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// OperationName returns the value of the operationName property. +func (o *MappingDocument) OperationName() string { + return o.operationName.Get() +} + +// SetOperationName sets the value of the operationName property. +func (o *MappingDocument) SetOperationName(v string) { + o.operationName.Set(v) +} + +// MessageDefinitionQualifiedName returns the value of the messageDefinition property. +func (o *MappingDocument) MessageDefinitionQualifiedName() string { + return o.messageDefinition.QualifiedName() +} + +// SetMessageDefinitionQualifiedName sets the value of the messageDefinition property. +func (o *MappingDocument) SetMessageDefinitionQualifiedName(v string) { + o.messageDefinition.SetQualifiedName(v) +} + +// MappingSourceReference returns the value of the mappingSourceReference property. +func (o *MappingDocument) MappingSourceReference() element.Element { + return o.mappingSourceReference.Get() +} + +// SetMappingSourceReference sets the value of the mappingSourceReference property. +func (o *MappingDocument) SetMappingSourceReference(v element.Element) { + o.mappingSourceReference.Set(v) +} + +// PublicName returns the value of the publicName property. +func (o *MappingDocument) PublicName() string { + return o.publicName.Get() +} + +// SetPublicName sets the value of the publicName property. +func (o *MappingDocument) SetPublicName(v string) { + o.publicName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MappingDocument) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "RootMappingElements"); err == nil { + for _, child := range children { + o.rootMappingElements.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("XmlSchema"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.xmlSchema.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("JsonStructure"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.jsonStructure.SetFromDecode(s) + } + } + o.rootElementName.Init(raw) + if val, err := raw.LookupErr("ImportedWebService"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.importedWebService.SetFromDecode(s) + } + } + o.serviceName.Init(raw) + o.operationName.Init(raw) + if val, err := raw.LookupErr("MessageDefinition"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.messageDefinition.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "MappingSourceReference"); err == nil { + o.mappingSourceReference.SetFromDecode(child) + } + o.publicName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MappingElement +// ──────────────────────────────────────────────────────── + +type MappingElement struct { + element.Base + documentation *property.Primitive[string] + elementType *property.Enum[string] + path *property.Primitive[string] + jsonPath *property.Primitive[string] + xmlPath *property.Primitive[string] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] +} + +// Documentation returns the value of the documentation property. +func (o *MappingElement) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MappingElement) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// ElementType returns the value of the elementType property. +func (o *MappingElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *MappingElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// Path returns the value of the path property. +func (o *MappingElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *MappingElement) SetPath(v string) { + o.path.Set(v) +} + +// JsonPath returns the value of the jsonPath property. +func (o *MappingElement) JsonPath() string { + return o.jsonPath.Get() +} + +// SetJsonPath sets the value of the jsonPath property. +func (o *MappingElement) SetJsonPath(v string) { + o.jsonPath.Set(v) +} + +// XmlPath returns the value of the xmlPath property. +func (o *MappingElement) XmlPath() string { + return o.xmlPath.Get() +} + +// SetXmlPath sets the value of the xmlPath property. +func (o *MappingElement) SetXmlPath(v string) { + o.xmlPath.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *MappingElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *MappingElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *MappingElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *MappingElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *MappingElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *MappingElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *MappingElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *MappingElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MappingElement) InitFromRaw(raw bson.Raw) { + o.documentation.Init(raw) + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.jsonPath.Init(raw) + o.xmlPath.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MappingMicroflowCall +// ──────────────────────────────────────────────────────── + +type MappingMicroflowCall struct { + element.Base + microflow *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MappingMicroflowCall) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MappingMicroflowCall) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *MappingMicroflowCall) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *MappingMicroflowCall) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *MappingMicroflowCall) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MappingMicroflowCall) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MappingMicroflowParameter +// ──────────────────────────────────────────────────────── + +type MappingMicroflowParameter struct { + element.Base + parameter *property.ByNameRef[element.Element] + levelOfParent *property.Primitive[int32] + valueElementPath *property.Primitive[string] + jsonValueElementPath *property.Primitive[string] + xmlValueElementPath *property.Primitive[string] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *MappingMicroflowParameter) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *MappingMicroflowParameter) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// LevelOfParent returns the value of the levelOfParent property. +func (o *MappingMicroflowParameter) LevelOfParent() int32 { + return o.levelOfParent.Get() +} + +// SetLevelOfParent sets the value of the levelOfParent property. +func (o *MappingMicroflowParameter) SetLevelOfParent(v int32) { + o.levelOfParent.Set(v) +} + +// ValueElementPath returns the value of the valueElementPath property. +func (o *MappingMicroflowParameter) ValueElementPath() string { + return o.valueElementPath.Get() +} + +// SetValueElementPath sets the value of the valueElementPath property. +func (o *MappingMicroflowParameter) SetValueElementPath(v string) { + o.valueElementPath.Set(v) +} + +// JsonValueElementPath returns the value of the jsonValueElementPath property. +func (o *MappingMicroflowParameter) JsonValueElementPath() string { + return o.jsonValueElementPath.Get() +} + +// SetJsonValueElementPath sets the value of the jsonValueElementPath property. +func (o *MappingMicroflowParameter) SetJsonValueElementPath(v string) { + o.jsonValueElementPath.Set(v) +} + +// XmlValueElementPath returns the value of the xmlValueElementPath property. +func (o *MappingMicroflowParameter) XmlValueElementPath() string { + return o.xmlValueElementPath.Get() +} + +// SetXmlValueElementPath sets the value of the xmlValueElementPath property. +func (o *MappingMicroflowParameter) SetXmlValueElementPath(v string) { + o.xmlValueElementPath.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MappingMicroflowParameter) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parameter.SetFromDecode(s) + } + } + o.levelOfParent.Init(raw) + o.valueElementPath.Init(raw) + o.jsonValueElementPath.Init(raw) + o.xmlValueElementPath.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MappingSource +// ──────────────────────────────────────────────────────── + +type MappingSource struct { + element.Base + name *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *MappingSource) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MappingSource) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MappingSource) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MappingSourceDocument +// ──────────────────────────────────────────────────────── + +type MappingSourceDocument struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *MappingSourceDocument) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MappingSourceDocument) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MappingSourceDocument) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MappingSourceDocument) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *MappingSourceDocument) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *MappingSourceDocument) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *MappingSourceDocument) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *MappingSourceDocument) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MappingSourceDocument) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// MappingSourceReference +// ──────────────────────────────────────────────────────── + +type MappingSourceReference struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MappingSourceReference) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ObjectMappingElement +// ──────────────────────────────────────────────────────── + +type ObjectMappingElement struct { + element.Base + documentation *property.Primitive[string] + elementType *property.Enum[string] + path *property.Primitive[string] + jsonPath *property.Primitive[string] + xmlPath *property.Primitive[string] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + mappingMicroflowCall *property.Part[element.Element] + children *property.PartList[element.Element] + entity *property.ByNameRef[element.Element] + association *property.ByNameRef[element.Element] + objectHandling *property.Enum[string] + objectHandlingBackup *property.Enum[string] + objectHandlingBackupAllowOverride *property.Primitive[bool] + isDefaultType *property.Primitive[bool] +} + +// Documentation returns the value of the documentation property. +func (o *ObjectMappingElement) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ObjectMappingElement) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// ElementType returns the value of the elementType property. +func (o *ObjectMappingElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ObjectMappingElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// Path returns the value of the path property. +func (o *ObjectMappingElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ObjectMappingElement) SetPath(v string) { + o.path.Set(v) +} + +// JsonPath returns the value of the jsonPath property. +func (o *ObjectMappingElement) JsonPath() string { + return o.jsonPath.Get() +} + +// SetJsonPath sets the value of the jsonPath property. +func (o *ObjectMappingElement) SetJsonPath(v string) { + o.jsonPath.Set(v) +} + +// XmlPath returns the value of the xmlPath property. +func (o *ObjectMappingElement) XmlPath() string { + return o.xmlPath.Get() +} + +// SetXmlPath sets the value of the xmlPath property. +func (o *ObjectMappingElement) SetXmlPath(v string) { + o.xmlPath.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ObjectMappingElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ObjectMappingElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ObjectMappingElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ObjectMappingElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ObjectMappingElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ObjectMappingElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ObjectMappingElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ObjectMappingElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// MappingMicroflowCall returns the value of the mappingMicroflowCall property. +func (o *ObjectMappingElement) MappingMicroflowCall() element.Element { + return o.mappingMicroflowCall.Get() +} + +// SetMappingMicroflowCall sets the value of the mappingMicroflowCall property. +func (o *ObjectMappingElement) SetMappingMicroflowCall(v element.Element) { + o.mappingMicroflowCall.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *ObjectMappingElement) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *ObjectMappingElement) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *ObjectMappingElement) RemoveChildren(index int) { + o.children.Remove(index) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ObjectMappingElement) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ObjectMappingElement) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *ObjectMappingElement) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *ObjectMappingElement) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// ObjectHandling returns the value of the objectHandling property. +func (o *ObjectMappingElement) ObjectHandling() string { + return o.objectHandling.Get() +} + +// SetObjectHandling sets the value of the objectHandling property. +func (o *ObjectMappingElement) SetObjectHandling(v string) { + o.objectHandling.Set(v) +} + +// ObjectHandlingBackup returns the value of the objectHandlingBackup property. +func (o *ObjectMappingElement) ObjectHandlingBackup() string { + return o.objectHandlingBackup.Get() +} + +// SetObjectHandlingBackup sets the value of the objectHandlingBackup property. +func (o *ObjectMappingElement) SetObjectHandlingBackup(v string) { + o.objectHandlingBackup.Set(v) +} + +// ObjectHandlingBackupAllowOverride returns the value of the objectHandlingBackupAllowOverride property. +func (o *ObjectMappingElement) ObjectHandlingBackupAllowOverride() bool { + return o.objectHandlingBackupAllowOverride.Get() +} + +// SetObjectHandlingBackupAllowOverride sets the value of the objectHandlingBackupAllowOverride property. +func (o *ObjectMappingElement) SetObjectHandlingBackupAllowOverride(v bool) { + o.objectHandlingBackupAllowOverride.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *ObjectMappingElement) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *ObjectMappingElement) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ObjectMappingElement) InitFromRaw(raw bson.Raw) { + o.documentation.Init(raw) + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.jsonPath.Init(raw) + o.xmlPath.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + if child, err := codec.DecodeChild(raw, "MappingMicroflowCall"); err == nil { + o.mappingMicroflowCall.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.association.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ObjectHandling"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.objectHandling.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ObjectHandlingBackup"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.objectHandlingBackup.SetFromDecode(s) + } + } + o.objectHandlingBackupAllowOverride.Init(raw) + o.isDefaultType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ValueMappingElement +// ──────────────────────────────────────────────────────── + +type ValueMappingElement struct { + element.Base + documentation *property.Primitive[string] + elementType *property.Enum[string] + path *property.Primitive[string] + jsonPath *property.Primitive[string] + xmlPath *property.Primitive[string] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + xmlDataType *property.Primitive[string] + propType *property.Part[element.Element] + isKey *property.Primitive[bool] + isXmlAttribute *property.Primitive[bool] + xmlPrimitiveType *property.Enum[string] + isContent *property.Primitive[bool] + attribute *property.ByNameRef[element.Element] + converter *property.ByNameRef[element.Element] + expectedContentTypes *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + originalValue *property.Primitive[string] +} + +// Documentation returns the value of the documentation property. +func (o *ValueMappingElement) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ValueMappingElement) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// ElementType returns the value of the elementType property. +func (o *ValueMappingElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ValueMappingElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// Path returns the value of the path property. +func (o *ValueMappingElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ValueMappingElement) SetPath(v string) { + o.path.Set(v) +} + +// JsonPath returns the value of the jsonPath property. +func (o *ValueMappingElement) JsonPath() string { + return o.jsonPath.Get() +} + +// SetJsonPath sets the value of the jsonPath property. +func (o *ValueMappingElement) SetJsonPath(v string) { + o.jsonPath.Set(v) +} + +// XmlPath returns the value of the xmlPath property. +func (o *ValueMappingElement) XmlPath() string { + return o.xmlPath.Get() +} + +// SetXmlPath sets the value of the xmlPath property. +func (o *ValueMappingElement) SetXmlPath(v string) { + o.xmlPath.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ValueMappingElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ValueMappingElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ValueMappingElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ValueMappingElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ValueMappingElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ValueMappingElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ValueMappingElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ValueMappingElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// XmlDataType returns the value of the xmlDataType property. +func (o *ValueMappingElement) XmlDataType() string { + return o.xmlDataType.Get() +} + +// SetXmlDataType sets the value of the xmlDataType property. +func (o *ValueMappingElement) SetXmlDataType(v string) { + o.xmlDataType.Set(v) +} + +// Type returns the value of the type property. +func (o *ValueMappingElement) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *ValueMappingElement) SetType(v element.Element) { + o.propType.Set(v) +} + +// IsKey returns the value of the isKey property. +func (o *ValueMappingElement) IsKey() bool { + return o.isKey.Get() +} + +// SetIsKey sets the value of the isKey property. +func (o *ValueMappingElement) SetIsKey(v bool) { + o.isKey.Set(v) +} + +// IsXmlAttribute returns the value of the isXmlAttribute property. +func (o *ValueMappingElement) IsXmlAttribute() bool { + return o.isXmlAttribute.Get() +} + +// SetIsXmlAttribute sets the value of the isXmlAttribute property. +func (o *ValueMappingElement) SetIsXmlAttribute(v bool) { + o.isXmlAttribute.Set(v) +} + +// XmlPrimitiveType returns the value of the xmlPrimitiveType property. +func (o *ValueMappingElement) XmlPrimitiveType() string { + return o.xmlPrimitiveType.Get() +} + +// SetXmlPrimitiveType sets the value of the xmlPrimitiveType property. +func (o *ValueMappingElement) SetXmlPrimitiveType(v string) { + o.xmlPrimitiveType.Set(v) +} + +// IsContent returns the value of the isContent property. +func (o *ValueMappingElement) IsContent() bool { + return o.isContent.Get() +} + +// SetIsContent sets the value of the isContent property. +func (o *ValueMappingElement) SetIsContent(v bool) { + o.isContent.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ValueMappingElement) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ValueMappingElement) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// ConverterQualifiedName returns the value of the converter property. +func (o *ValueMappingElement) ConverterQualifiedName() string { + return o.converter.QualifiedName() +} + +// SetConverterQualifiedName sets the value of the converter property. +func (o *ValueMappingElement) SetConverterQualifiedName(v string) { + o.converter.SetQualifiedName(v) +} + +// ExpectedContentTypes returns the value of the expectedContentTypes property. +func (o *ValueMappingElement) ExpectedContentTypes() string { + return o.expectedContentTypes.Get() +} + +// SetExpectedContentTypes sets the value of the expectedContentTypes property. +func (o *ValueMappingElement) SetExpectedContentTypes(v string) { + o.expectedContentTypes.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *ValueMappingElement) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *ValueMappingElement) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *ValueMappingElement) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *ValueMappingElement) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *ValueMappingElement) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *ValueMappingElement) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// OriginalValue returns the value of the originalValue property. +func (o *ValueMappingElement) OriginalValue() string { + return o.originalValue.Get() +} + +// SetOriginalValue sets the value of the originalValue property. +func (o *ValueMappingElement) SetOriginalValue(v string) { + o.originalValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ValueMappingElement) InitFromRaw(raw bson.Raw) { + o.documentation.Init(raw) + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.jsonPath.Init(raw) + o.xmlPath.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.xmlDataType.Init(raw) + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } + o.isKey.Init(raw) + o.isXmlAttribute.Init(raw) + if val, err := raw.LookupErr("XmlPrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.xmlPrimitiveType.SetFromDecode(s) + } + } + o.isContent.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Converter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.converter.SetFromDecode(s) + } + } + o.expectedContentTypes.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.originalValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initMappingMicroflowCall creates a MappingMicroflowCall with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMappingMicroflowCall() *MappingMicroflowCall { + o := &MappingMicroflowCall{} + o.SetTypeName("Mappings$MappingMicroflowCallImpl") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.microflow, o.parameterMappings}) + return o +} + +// NewMappingMicroflowCall creates a new MappingMicroflowCall for user code. Marked dirty (bit 63 = new element). +func NewMappingMicroflowCall() *MappingMicroflowCall { + o := initMappingMicroflowCall() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMappingMicroflowParameter creates a MappingMicroflowParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMappingMicroflowParameter() *MappingMicroflowParameter { + o := &MappingMicroflowParameter{} + o.SetTypeName("Mappings$MappingMicroflowParameter") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Microflows$MicroflowParameter") + o.parameter.Bind(&o.Base, 0) + o.levelOfParent = property.NewPrimitive[int32]("LevelOfParent", property.DecodeInt32) + o.levelOfParent.Bind(&o.Base, 1) + o.valueElementPath = property.NewPrimitive[string]("ValueElementPath", property.DecodeString) + o.valueElementPath.Bind(&o.Base, 2) + o.jsonValueElementPath = property.NewPrimitive[string]("JsonValueElementPath", property.DecodeString) + o.jsonValueElementPath.Bind(&o.Base, 3) + o.xmlValueElementPath = property.NewPrimitive[string]("XmlValueElementPath", property.DecodeString) + o.xmlValueElementPath.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.parameter, o.levelOfParent, o.valueElementPath, o.jsonValueElementPath, o.xmlValueElementPath}) + return o +} + +// NewMappingMicroflowParameter creates a new MappingMicroflowParameter for user code. Marked dirty (bit 63 = new element). +func NewMappingMicroflowParameter() *MappingMicroflowParameter { + o := initMappingMicroflowParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Mappings$MappingMicroflowCall", func() element.Element { + o := initMappingMicroflowCall() + o.SetTypeName("Mappings$MappingMicroflowCall") + return o + }) + codec.DefaultRegistry.Register("Mappings$MappingMicroflowCallImpl", func() element.Element { + return initMappingMicroflowCall() + }) + codec.DefaultRegistry.Register("Mappings$MappingMicroflowParameter", func() element.Element { + return initMappingMicroflowParameter() + }) +} diff --git a/modelsdk/gen/mappings/version.go b/modelsdk/gen/mappings/version.go new file mode 100644 index 00000000..d84a751c --- /dev/null +++ b/modelsdk/gen/mappings/version.go @@ -0,0 +1,59 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package mappings + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Mappings$Element": { + Properties: map[string]version.PropertyVersionInfo{ + "exposedItemName": {Introduced: "7.6.0"}, + }, + }, + "Mappings$MappingDocument": { + Properties: map[string]version.PropertyVersionInfo{ + "jsonStructure": {Introduced: "6.4.0"}, + "mappingSourceReference": {Introduced: "10.16.0", Public: true}, + "messageDefinition": {Introduced: "7.6.0"}, + "publicName": {Introduced: "7.14.0"}, + }, + }, + "Mappings$MappingElement": { + Properties: map[string]version.PropertyVersionInfo{ + "exposedName": {Introduced: "6.6.0"}, + "jsonPath": {Introduced: "7.6.0"}, + "path": {Deleted: "7.6.0"}, + "xmlPath": {Introduced: "7.6.0"}, + }, + }, + "Mappings$MappingMicroflowParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "jsonValueElementPath": {Introduced: "7.6.0"}, + "valueElementPath": {Deleted: "7.6.0"}, + "xmlValueElementPath": {Introduced: "7.6.0"}, + }, + }, + "Mappings$MappingSource": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Introduced: "10.15.0", Public: true}, + }, + }, + "Mappings$ObjectMappingElement": { + Properties: map[string]version.PropertyVersionInfo{ + "isDefaultType": {Introduced: "6.4.0"}, + "objectHandlingBackupAllowOverride": {Introduced: "7.17.0"}, + }, + }, + "Mappings$ValueMappingElement": { + Properties: map[string]version.PropertyVersionInfo{ + "expectedContentTypes": {Deleted: "6.4.1"}, + "originalValue": {Introduced: "10.3.0"}, + "type": {Introduced: "7.9.0", Required: true}, + "xmlDataType": {Deleted: "7.9.0"}, + "xmlPrimitiveType": {Introduced: "6.1.0"}, + }, + }, +} diff --git a/modelsdk/gen/menus/enums.go b/modelsdk/gen/menus/enums.go new file mode 100644 index 00000000..82ff18b4 --- /dev/null +++ b/modelsdk/gen/menus/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package menus diff --git a/modelsdk/gen/menus/refs.go b/modelsdk/gen/menus/refs.go new file mode 100644 index 00000000..82ff18b4 --- /dev/null +++ b/modelsdk/gen/menus/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package menus diff --git a/modelsdk/gen/menus/types.go b/modelsdk/gen/menus/types.go new file mode 100644 index 00000000..0bb56114 --- /dev/null +++ b/modelsdk/gen/menus/types.go @@ -0,0 +1,348 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package menus + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// MenuDocument +// ──────────────────────────────────────────────────────── + +type MenuDocument struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + itemCollection *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *MenuDocument) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MenuDocument) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MenuDocument) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MenuDocument) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *MenuDocument) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *MenuDocument) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *MenuDocument) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *MenuDocument) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ItemCollection returns the value of the itemCollection property. +func (o *MenuDocument) ItemCollection() element.Element { + return o.itemCollection.Get() +} + +// SetItemCollection sets the value of the itemCollection property. +func (o *MenuDocument) SetItemCollection(v element.Element) { + o.itemCollection.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MenuDocument) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "ItemCollection"); err == nil { + o.itemCollection.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MenuItemContainer +// ──────────────────────────────────────────────────────── + +type MenuItemContainer struct { + element.Base + items *property.PartList[element.Element] +} + +// ItemsItems returns the value of the items property. +func (o *MenuItemContainer) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *MenuItemContainer) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *MenuItemContainer) RemoveItems(index int) { + o.items.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MenuItemContainer) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MenuItem +// ──────────────────────────────────────────────────────── + +type MenuItem struct { + element.Base + items *property.PartList[element.Element] + caption *property.Part[element.Element] + icon *property.Part[element.Element] + alternativeText *property.Part[element.Element] + action *property.Part[element.Element] +} + +// ItemsItems returns the value of the items property. +func (o *MenuItem) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *MenuItem) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *MenuItem) RemoveItems(index int) { + o.items.Remove(index) +} + +// Caption returns the value of the caption property. +func (o *MenuItem) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *MenuItem) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Icon returns the value of the icon property. +func (o *MenuItem) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *MenuItem) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// AlternativeText returns the value of the alternativeText property. +func (o *MenuItem) AlternativeText() element.Element { + return o.alternativeText.Get() +} + +// SetAlternativeText sets the value of the alternativeText property. +func (o *MenuItem) SetAlternativeText(v element.Element) { + o.alternativeText.Set(v) +} + +// Action returns the value of the action property. +func (o *MenuItem) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *MenuItem) SetAction(v element.Element) { + o.action.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MenuItem) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AlternativeText"); err == nil { + o.alternativeText.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MenuItemCollection +// ──────────────────────────────────────────────────────── + +type MenuItemCollection struct { + element.Base + items *property.PartList[element.Element] +} + +// ItemsItems returns the value of the items property. +func (o *MenuItemCollection) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *MenuItemCollection) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *MenuItemCollection) RemoveItems(index int) { + o.items.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MenuItemCollection) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initMenuDocument creates a MenuDocument with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMenuDocument() *MenuDocument { + o := &MenuDocument{} + o.SetTypeName("Menus$MenuDocument") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.itemCollection = property.NewPart[element.Element]("ItemCollection") + o.itemCollection.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.itemCollection}) + return o +} + +// NewMenuDocument creates a new MenuDocument for user code. Marked dirty (bit 63 = new element). +func NewMenuDocument() *MenuDocument { + o := initMenuDocument() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMenuItem creates a MenuItem with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMenuItem() *MenuItem { + o := &MenuItem{} + o.SetTypeName("Menus$MenuItem") + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 2) + o.alternativeText = property.NewPart[element.Element]("AlternativeText") + o.alternativeText.Bind(&o.Base, 3) + o.action = property.NewPart[element.Element]("Action") + o.action.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.items, o.caption, o.icon, o.alternativeText, o.action}) + return o +} + +// NewMenuItem creates a new MenuItem for user code. Marked dirty (bit 63 = new element). +func NewMenuItem() *MenuItem { + o := initMenuItem() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMenuItemCollection creates a MenuItemCollection with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMenuItemCollection() *MenuItemCollection { + o := &MenuItemCollection{} + o.SetTypeName("Menus$MenuItemCollection") + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.items}) + return o +} + +// NewMenuItemCollection creates a new MenuItemCollection for user code. Marked dirty (bit 63 = new element). +func NewMenuItemCollection() *MenuItemCollection { + o := initMenuItemCollection() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Menus$MenuDocument", func() element.Element { + return initMenuDocument() + }) + codec.DefaultRegistry.Register("Menus$MenuItem", func() element.Element { + return initMenuItem() + }) + codec.DefaultRegistry.Register("Menus$MenuItemCollection", func() element.Element { + return initMenuItemCollection() + }) +} diff --git a/modelsdk/gen/menus/version.go b/modelsdk/gen/menus/version.go new file mode 100644 index 00000000..264ede13 --- /dev/null +++ b/modelsdk/gen/menus/version.go @@ -0,0 +1,23 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package menus + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Menus$MenuDocument": { + Properties: map[string]version.PropertyVersionInfo{ + "itemCollection": {Required: true}, + }, + }, + "Menus$MenuItem": { + Properties: map[string]version.PropertyVersionInfo{ + "action": {Required: true}, + "alternativeText": {Introduced: "8.12.0"}, + "caption": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/messagedefinitions/enums.go b/modelsdk/gen/messagedefinitions/enums.go new file mode 100644 index 00000000..be6e226c --- /dev/null +++ b/modelsdk/gen/messagedefinitions/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package messagedefinitions diff --git a/modelsdk/gen/messagedefinitions/refs.go b/modelsdk/gen/messagedefinitions/refs.go new file mode 100644 index 00000000..15dca37b --- /dev/null +++ b/modelsdk/gen/messagedefinitions/refs.go @@ -0,0 +1,23 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package messagedefinitions + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("MessageDefinitions$ExposedEntityBase", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("MessageDefinitions$ExposedAssociation", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("MessageDefinitions$ExposedAttribute", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("MessageDefinitions$ExposedEntity", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) +} diff --git a/modelsdk/gen/messagedefinitions/types.go b/modelsdk/gen/messagedefinitions/types.go new file mode 100644 index 00000000..3c2d7c3d --- /dev/null +++ b/modelsdk/gen/messagedefinitions/types.go @@ -0,0 +1,2528 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package messagedefinitions + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// AssociationElement +// ──────────────────────────────────────────────────────── + +type AssociationElement struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] +} + +// ElementType returns the value of the elementType property. +func (o *AssociationElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *AssociationElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *AssociationElement) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *AssociationElement) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *AssociationElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *AssociationElement) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *AssociationElement) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *AssociationElement) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *AssociationElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *AssociationElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *AssociationElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *AssociationElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *AssociationElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *AssociationElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *AssociationElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *AssociationElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *AssociationElement) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *AssociationElement) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *AssociationElement) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *AssociationElement) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *AssociationElement) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *AssociationElement) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *AssociationElement) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *AssociationElement) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *AssociationElement) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *AssociationElement) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *AssociationElement) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *AssociationElement) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *AssociationElement) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *AssociationElement) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *AssociationElement) RemoveChildren(index int) { + o.children.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AssociationElement) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// AttributeElement +// ──────────────────────────────────────────────────────── + +type AttributeElement struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] +} + +// ElementType returns the value of the elementType property. +func (o *AttributeElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *AttributeElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *AttributeElement) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *AttributeElement) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *AttributeElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *AttributeElement) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *AttributeElement) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *AttributeElement) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *AttributeElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *AttributeElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *AttributeElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *AttributeElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *AttributeElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *AttributeElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *AttributeElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *AttributeElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *AttributeElement) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *AttributeElement) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *AttributeElement) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *AttributeElement) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *AttributeElement) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *AttributeElement) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *AttributeElement) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *AttributeElement) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *AttributeElement) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *AttributeElement) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *AttributeElement) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *AttributeElement) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *AttributeElement) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *AttributeElement) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *AttributeElement) RemoveChildren(index int) { + o.children.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AttributeElement) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// EntityElement +// ──────────────────────────────────────────────────────── + +type EntityElement struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] +} + +// ElementType returns the value of the elementType property. +func (o *EntityElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *EntityElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *EntityElement) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *EntityElement) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *EntityElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *EntityElement) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *EntityElement) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *EntityElement) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *EntityElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *EntityElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *EntityElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *EntityElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *EntityElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *EntityElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *EntityElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *EntityElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *EntityElement) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *EntityElement) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *EntityElement) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *EntityElement) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *EntityElement) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *EntityElement) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *EntityElement) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *EntityElement) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *EntityElement) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *EntityElement) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *EntityElement) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *EntityElement) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *EntityElement) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *EntityElement) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *EntityElement) RemoveChildren(index int) { + o.children.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityElement) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MessageDefinition +// ──────────────────────────────────────────────────────── + +type MessageDefinition struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *MessageDefinition) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MessageDefinition) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MessageDefinition) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MessageDefinition) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MessageDefinition) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EntityMessageDefinition +// ──────────────────────────────────────────────────────── + +type EntityMessageDefinition struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + exposedEntity *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *EntityMessageDefinition) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *EntityMessageDefinition) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *EntityMessageDefinition) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *EntityMessageDefinition) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// ExposedEntity returns the value of the exposedEntity property. +func (o *EntityMessageDefinition) ExposedEntity() element.Element { + return o.exposedEntity.Get() +} + +// SetExposedEntity sets the value of the exposedEntity property. +func (o *EntityMessageDefinition) SetExposedEntity(v element.Element) { + o.exposedEntity.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityMessageDefinition) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + if child, err := codec.DecodeChild(raw, "ExposedEntity"); err == nil { + o.exposedEntity.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ExposedMember +// ──────────────────────────────────────────────────────── + +type ExposedMember struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] + originalName *property.Primitive[string] + documentation *property.Primitive[string] + example *property.Primitive[string] +} + +// ElementType returns the value of the elementType property. +func (o *ExposedMember) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ExposedMember) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *ExposedMember) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *ExposedMember) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *ExposedMember) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ExposedMember) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *ExposedMember) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *ExposedMember) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ExposedMember) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ExposedMember) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ExposedMember) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ExposedMember) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ExposedMember) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ExposedMember) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ExposedMember) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ExposedMember) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *ExposedMember) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *ExposedMember) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *ExposedMember) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *ExposedMember) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *ExposedMember) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *ExposedMember) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *ExposedMember) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *ExposedMember) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *ExposedMember) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *ExposedMember) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *ExposedMember) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *ExposedMember) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *ExposedMember) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *ExposedMember) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *ExposedMember) RemoveChildren(index int) { + o.children.Remove(index) +} + +// OriginalName returns the value of the originalName property. +func (o *ExposedMember) OriginalName() string { + return o.originalName.Get() +} + +// SetOriginalName sets the value of the originalName property. +func (o *ExposedMember) SetOriginalName(v string) { + o.originalName.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ExposedMember) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ExposedMember) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Example returns the value of the example property. +func (o *ExposedMember) Example() string { + return o.example.Get() +} + +// SetExample sets the value of the example property. +func (o *ExposedMember) SetExample(v string) { + o.example.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExposedMember) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } + o.originalName.Init(raw) + o.documentation.Init(raw) + o.example.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ExposedEntityBase +// ──────────────────────────────────────────────────────── + +type ExposedEntityBase struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] + originalName *property.Primitive[string] + documentation *property.Primitive[string] + example *property.Primitive[string] + entity *property.ByNameRef[element.Element] +} + +// ElementType returns the value of the elementType property. +func (o *ExposedEntityBase) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ExposedEntityBase) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *ExposedEntityBase) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *ExposedEntityBase) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *ExposedEntityBase) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ExposedEntityBase) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *ExposedEntityBase) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *ExposedEntityBase) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ExposedEntityBase) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ExposedEntityBase) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ExposedEntityBase) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ExposedEntityBase) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ExposedEntityBase) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ExposedEntityBase) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ExposedEntityBase) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ExposedEntityBase) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *ExposedEntityBase) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *ExposedEntityBase) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *ExposedEntityBase) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *ExposedEntityBase) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *ExposedEntityBase) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *ExposedEntityBase) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *ExposedEntityBase) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *ExposedEntityBase) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *ExposedEntityBase) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *ExposedEntityBase) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *ExposedEntityBase) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *ExposedEntityBase) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *ExposedEntityBase) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *ExposedEntityBase) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *ExposedEntityBase) RemoveChildren(index int) { + o.children.Remove(index) +} + +// OriginalName returns the value of the originalName property. +func (o *ExposedEntityBase) OriginalName() string { + return o.originalName.Get() +} + +// SetOriginalName sets the value of the originalName property. +func (o *ExposedEntityBase) SetOriginalName(v string) { + o.originalName.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ExposedEntityBase) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ExposedEntityBase) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Example returns the value of the example property. +func (o *ExposedEntityBase) Example() string { + return o.example.Get() +} + +// SetExample sets the value of the example property. +func (o *ExposedEntityBase) SetExample(v string) { + o.example.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ExposedEntityBase) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ExposedEntityBase) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExposedEntityBase) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } + o.originalName.Init(raw) + o.documentation.Init(raw) + o.example.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ExposedAssociation +// ──────────────────────────────────────────────────────── + +type ExposedAssociation struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] + originalName *property.Primitive[string] + documentation *property.Primitive[string] + example *property.Primitive[string] + entity *property.ByNameRef[element.Element] + association *property.ByNameRef[element.Element] +} + +// ElementType returns the value of the elementType property. +func (o *ExposedAssociation) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ExposedAssociation) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *ExposedAssociation) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *ExposedAssociation) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *ExposedAssociation) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ExposedAssociation) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *ExposedAssociation) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *ExposedAssociation) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ExposedAssociation) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ExposedAssociation) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ExposedAssociation) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ExposedAssociation) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ExposedAssociation) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ExposedAssociation) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ExposedAssociation) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ExposedAssociation) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *ExposedAssociation) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *ExposedAssociation) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *ExposedAssociation) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *ExposedAssociation) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *ExposedAssociation) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *ExposedAssociation) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *ExposedAssociation) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *ExposedAssociation) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *ExposedAssociation) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *ExposedAssociation) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *ExposedAssociation) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *ExposedAssociation) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *ExposedAssociation) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *ExposedAssociation) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *ExposedAssociation) RemoveChildren(index int) { + o.children.Remove(index) +} + +// OriginalName returns the value of the originalName property. +func (o *ExposedAssociation) OriginalName() string { + return o.originalName.Get() +} + +// SetOriginalName sets the value of the originalName property. +func (o *ExposedAssociation) SetOriginalName(v string) { + o.originalName.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ExposedAssociation) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ExposedAssociation) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Example returns the value of the example property. +func (o *ExposedAssociation) Example() string { + return o.example.Get() +} + +// SetExample sets the value of the example property. +func (o *ExposedAssociation) SetExample(v string) { + o.example.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ExposedAssociation) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ExposedAssociation) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *ExposedAssociation) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *ExposedAssociation) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExposedAssociation) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } + o.originalName.Init(raw) + o.documentation.Init(raw) + o.example.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.association.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ExposedAttribute +// ──────────────────────────────────────────────────────── + +type ExposedAttribute struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] + originalName *property.Primitive[string] + documentation *property.Primitive[string] + example *property.Primitive[string] + attribute *property.ByNameRef[element.Element] +} + +// ElementType returns the value of the elementType property. +func (o *ExposedAttribute) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ExposedAttribute) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *ExposedAttribute) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *ExposedAttribute) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *ExposedAttribute) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ExposedAttribute) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *ExposedAttribute) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *ExposedAttribute) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ExposedAttribute) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ExposedAttribute) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ExposedAttribute) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ExposedAttribute) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ExposedAttribute) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ExposedAttribute) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ExposedAttribute) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ExposedAttribute) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *ExposedAttribute) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *ExposedAttribute) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *ExposedAttribute) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *ExposedAttribute) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *ExposedAttribute) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *ExposedAttribute) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *ExposedAttribute) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *ExposedAttribute) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *ExposedAttribute) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *ExposedAttribute) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *ExposedAttribute) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *ExposedAttribute) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *ExposedAttribute) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *ExposedAttribute) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *ExposedAttribute) RemoveChildren(index int) { + o.children.Remove(index) +} + +// OriginalName returns the value of the originalName property. +func (o *ExposedAttribute) OriginalName() string { + return o.originalName.Get() +} + +// SetOriginalName sets the value of the originalName property. +func (o *ExposedAttribute) SetOriginalName(v string) { + o.originalName.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ExposedAttribute) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ExposedAttribute) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Example returns the value of the example property. +func (o *ExposedAttribute) Example() string { + return o.example.Get() +} + +// SetExample sets the value of the example property. +func (o *ExposedAttribute) SetExample(v string) { + o.example.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ExposedAttribute) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ExposedAttribute) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExposedAttribute) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } + o.originalName.Init(raw) + o.documentation.Init(raw) + o.example.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ExposedEntity +// ──────────────────────────────────────────────────────── + +type ExposedEntity struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] + originalName *property.Primitive[string] + documentation *property.Primitive[string] + example *property.Primitive[string] + entity *property.ByNameRef[element.Element] +} + +// ElementType returns the value of the elementType property. +func (o *ExposedEntity) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *ExposedEntity) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *ExposedEntity) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *ExposedEntity) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *ExposedEntity) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *ExposedEntity) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *ExposedEntity) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *ExposedEntity) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *ExposedEntity) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *ExposedEntity) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *ExposedEntity) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *ExposedEntity) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *ExposedEntity) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *ExposedEntity) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *ExposedEntity) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *ExposedEntity) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *ExposedEntity) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *ExposedEntity) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *ExposedEntity) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *ExposedEntity) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *ExposedEntity) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *ExposedEntity) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *ExposedEntity) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *ExposedEntity) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *ExposedEntity) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *ExposedEntity) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *ExposedEntity) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *ExposedEntity) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *ExposedEntity) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *ExposedEntity) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *ExposedEntity) RemoveChildren(index int) { + o.children.Remove(index) +} + +// OriginalName returns the value of the originalName property. +func (o *ExposedEntity) OriginalName() string { + return o.originalName.Get() +} + +// SetOriginalName sets the value of the originalName property. +func (o *ExposedEntity) SetOriginalName(v string) { + o.originalName.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ExposedEntity) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ExposedEntity) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Example returns the value of the example property. +func (o *ExposedEntity) Example() string { + return o.example.Get() +} + +// SetExample sets the value of the example property. +func (o *ExposedEntity) SetExample(v string) { + o.example.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ExposedEntity) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ExposedEntity) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExposedEntity) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } + o.originalName.Init(raw) + o.documentation.Init(raw) + o.example.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// MessageDefinitionCollection +// ──────────────────────────────────────────────────────── + +type MessageDefinitionCollection struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + messageDefinitions *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *MessageDefinitionCollection) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MessageDefinitionCollection) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MessageDefinitionCollection) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MessageDefinitionCollection) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *MessageDefinitionCollection) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *MessageDefinitionCollection) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *MessageDefinitionCollection) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *MessageDefinitionCollection) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// MessageDefinitionsItems returns the value of the messageDefinitions property. +func (o *MessageDefinitionCollection) MessageDefinitionsItems() []element.Element { + return o.messageDefinitions.Items() +} + +// AddMessageDefinitions appends a child element to the messageDefinitions list. +func (o *MessageDefinitionCollection) AddMessageDefinitions(v element.Element) { + o.messageDefinitions.Append(v) +} + +// RemoveMessageDefinitions removes the element at the given index from the messageDefinitions list. +func (o *MessageDefinitionCollection) RemoveMessageDefinitions(index int) { + o.messageDefinitions.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MessageDefinitionCollection) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "MessageDefinitions"); err == nil { + for _, child := range children { + o.messageDefinitions.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initAssociationElement creates a AssociationElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAssociationElement() *AssociationElement { + o := &AssociationElement{} + o.SetTypeName("MessageDefinitions$AssociationElement") + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 0) + o.primitiveType = property.NewEnum[string]("PrimitiveType") + o.primitiveType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 3) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 4) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 5) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 6) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 7) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 8) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 9) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 10) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 11) + o.errorMessage = property.NewPrimitive[string]("ErrorMessage", property.DecodeString) + o.errorMessage.Bind(&o.Base, 12) + o.warningMessage = property.NewPrimitive[string]("WarningMessage", property.DecodeString) + o.warningMessage.Bind(&o.Base, 13) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.elementType, o.primitiveType, o.path, o.isDefaultType, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.exposedItemName, o.maxLength, o.fractionDigits, o.totalDigits, o.errorMessage, o.warningMessage, o.children}) + return o +} + +// NewAssociationElement creates a new AssociationElement for user code. Marked dirty (bit 63 = new element). +func NewAssociationElement() *AssociationElement { + o := initAssociationElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAttributeElement creates a AttributeElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAttributeElement() *AttributeElement { + o := &AttributeElement{} + o.SetTypeName("MessageDefinitions$AttributeElement") + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 0) + o.primitiveType = property.NewEnum[string]("PrimitiveType") + o.primitiveType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 3) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 4) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 5) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 6) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 7) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 8) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 9) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 10) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 11) + o.errorMessage = property.NewPrimitive[string]("ErrorMessage", property.DecodeString) + o.errorMessage.Bind(&o.Base, 12) + o.warningMessage = property.NewPrimitive[string]("WarningMessage", property.DecodeString) + o.warningMessage.Bind(&o.Base, 13) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.elementType, o.primitiveType, o.path, o.isDefaultType, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.exposedItemName, o.maxLength, o.fractionDigits, o.totalDigits, o.errorMessage, o.warningMessage, o.children}) + return o +} + +// NewAttributeElement creates a new AttributeElement for user code. Marked dirty (bit 63 = new element). +func NewAttributeElement() *AttributeElement { + o := initAttributeElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityElement creates a EntityElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityElement() *EntityElement { + o := &EntityElement{} + o.SetTypeName("MessageDefinitions$EntityElement") + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 0) + o.primitiveType = property.NewEnum[string]("PrimitiveType") + o.primitiveType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 3) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 4) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 5) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 6) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 7) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 8) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 9) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 10) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 11) + o.errorMessage = property.NewPrimitive[string]("ErrorMessage", property.DecodeString) + o.errorMessage.Bind(&o.Base, 12) + o.warningMessage = property.NewPrimitive[string]("WarningMessage", property.DecodeString) + o.warningMessage.Bind(&o.Base, 13) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.elementType, o.primitiveType, o.path, o.isDefaultType, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.exposedItemName, o.maxLength, o.fractionDigits, o.totalDigits, o.errorMessage, o.warningMessage, o.children}) + return o +} + +// NewEntityElement creates a new EntityElement for user code. Marked dirty (bit 63 = new element). +func NewEntityElement() *EntityElement { + o := initEntityElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityMessageDefinition creates a EntityMessageDefinition with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityMessageDefinition() *EntityMessageDefinition { + o := &EntityMessageDefinition{} + o.SetTypeName("MessageDefinitions$EntityMessageDefinition") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.exposedEntity = property.NewPart[element.Element]("ExposedEntity") + o.exposedEntity.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.documentation, o.exposedEntity}) + return o +} + +// NewEntityMessageDefinition creates a new EntityMessageDefinition for user code. Marked dirty (bit 63 = new element). +func NewEntityMessageDefinition() *EntityMessageDefinition { + o := initEntityMessageDefinition() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExposedAssociation creates a ExposedAssociation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExposedAssociation() *ExposedAssociation { + o := &ExposedAssociation{} + o.SetTypeName("MessageDefinitions$ExposedAssociation") + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 0) + o.primitiveType = property.NewEnum[string]("PrimitiveType") + o.primitiveType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 3) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 4) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 5) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 6) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 7) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 8) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 9) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 10) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 11) + o.errorMessage = property.NewPrimitive[string]("ErrorMessage", property.DecodeString) + o.errorMessage.Bind(&o.Base, 12) + o.warningMessage = property.NewPrimitive[string]("WarningMessage", property.DecodeString) + o.warningMessage.Bind(&o.Base, 13) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 14) + o.originalName = property.NewPrimitive[string]("OriginalName", property.DecodeString) + o.originalName.Bind(&o.Base, 15) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 16) + o.example = property.NewPrimitive[string]("Example", property.DecodeString) + o.example.Bind(&o.Base, 17) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 18) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 19) + o.SetProperties([]element.Property{o.elementType, o.primitiveType, o.path, o.isDefaultType, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.exposedItemName, o.maxLength, o.fractionDigits, o.totalDigits, o.errorMessage, o.warningMessage, o.children, o.originalName, o.documentation, o.example, o.entity, o.association}) + return o +} + +// NewExposedAssociation creates a new ExposedAssociation for user code. Marked dirty (bit 63 = new element). +func NewExposedAssociation() *ExposedAssociation { + o := initExposedAssociation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExposedAttribute creates a ExposedAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExposedAttribute() *ExposedAttribute { + o := &ExposedAttribute{} + o.SetTypeName("MessageDefinitions$ExposedAttribute") + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 0) + o.primitiveType = property.NewEnum[string]("PrimitiveType") + o.primitiveType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 3) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 4) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 5) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 6) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 7) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 8) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 9) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 10) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 11) + o.errorMessage = property.NewPrimitive[string]("ErrorMessage", property.DecodeString) + o.errorMessage.Bind(&o.Base, 12) + o.warningMessage = property.NewPrimitive[string]("WarningMessage", property.DecodeString) + o.warningMessage.Bind(&o.Base, 13) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 14) + o.originalName = property.NewPrimitive[string]("OriginalName", property.DecodeString) + o.originalName.Bind(&o.Base, 15) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 16) + o.example = property.NewPrimitive[string]("Example", property.DecodeString) + o.example.Bind(&o.Base, 17) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 18) + o.SetProperties([]element.Property{o.elementType, o.primitiveType, o.path, o.isDefaultType, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.exposedItemName, o.maxLength, o.fractionDigits, o.totalDigits, o.errorMessage, o.warningMessage, o.children, o.originalName, o.documentation, o.example, o.attribute}) + return o +} + +// NewExposedAttribute creates a new ExposedAttribute for user code. Marked dirty (bit 63 = new element). +func NewExposedAttribute() *ExposedAttribute { + o := initExposedAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExposedEntity creates a ExposedEntity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExposedEntity() *ExposedEntity { + o := &ExposedEntity{} + o.SetTypeName("MessageDefinitions$ExposedEntity") + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 0) + o.primitiveType = property.NewEnum[string]("PrimitiveType") + o.primitiveType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 3) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 4) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 5) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 6) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 7) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 8) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 9) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 10) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 11) + o.errorMessage = property.NewPrimitive[string]("ErrorMessage", property.DecodeString) + o.errorMessage.Bind(&o.Base, 12) + o.warningMessage = property.NewPrimitive[string]("WarningMessage", property.DecodeString) + o.warningMessage.Bind(&o.Base, 13) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 14) + o.originalName = property.NewPrimitive[string]("OriginalName", property.DecodeString) + o.originalName.Bind(&o.Base, 15) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 16) + o.example = property.NewPrimitive[string]("Example", property.DecodeString) + o.example.Bind(&o.Base, 17) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 18) + o.SetProperties([]element.Property{o.elementType, o.primitiveType, o.path, o.isDefaultType, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.exposedItemName, o.maxLength, o.fractionDigits, o.totalDigits, o.errorMessage, o.warningMessage, o.children, o.originalName, o.documentation, o.example, o.entity}) + return o +} + +// NewExposedEntity creates a new ExposedEntity for user code. Marked dirty (bit 63 = new element). +func NewExposedEntity() *ExposedEntity { + o := initExposedEntity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMessageDefinitionCollection creates a MessageDefinitionCollection with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMessageDefinitionCollection() *MessageDefinitionCollection { + o := &MessageDefinitionCollection{} + o.SetTypeName("MessageDefinitions$MessageDefinitionCollection") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.messageDefinitions = property.NewPartList[element.Element]("MessageDefinitions") + o.messageDefinitions.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.messageDefinitions}) + return o +} + +// NewMessageDefinitionCollection creates a new MessageDefinitionCollection for user code. Marked dirty (bit 63 = new element). +func NewMessageDefinitionCollection() *MessageDefinitionCollection { + o := initMessageDefinitionCollection() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("MessageDefinitions$AssociationElement", func() element.Element { + return initAssociationElement() + }) + codec.DefaultRegistry.Register("MessageDefinitions$AttributeElement", func() element.Element { + return initAttributeElement() + }) + codec.DefaultRegistry.Register("MessageDefinitions$EntityElement", func() element.Element { + return initEntityElement() + }) + codec.DefaultRegistry.Register("MessageDefinitions$EntityMessageDefinition", func() element.Element { + return initEntityMessageDefinition() + }) + codec.DefaultRegistry.Register("MessageDefinitions$ExposedAssociation", func() element.Element { + return initExposedAssociation() + }) + codec.DefaultRegistry.Register("MessageDefinitions$ExposedAttribute", func() element.Element { + return initExposedAttribute() + }) + codec.DefaultRegistry.Register("MessageDefinitions$ExposedEntity", func() element.Element { + return initExposedEntity() + }) + codec.DefaultRegistry.Register("MessageDefinitions$MessageDefinitionCollection", func() element.Element { + return initMessageDefinitionCollection() + }) +} diff --git a/modelsdk/gen/messagedefinitions/version.go b/modelsdk/gen/messagedefinitions/version.go new file mode 100644 index 00000000..72677ab9 --- /dev/null +++ b/modelsdk/gen/messagedefinitions/version.go @@ -0,0 +1,42 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package messagedefinitions + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "MessageDefinitions$MessageDefinition": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + }, + }, + "MessageDefinitions$ExposedMember": { + Properties: map[string]version.PropertyVersionInfo{ + "documentation": {Introduced: "7.15.0"}, + "example": {Introduced: "7.15.0"}, + }, + }, + "MessageDefinitions$ExposedEntityBase": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true}, + }, + }, + "MessageDefinitions$ExposedAssociation": { + Properties: map[string]version.PropertyVersionInfo{ + "association": {Required: true}, + }, + }, + "MessageDefinitions$ExposedAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Required: true}, + }, + }, + "MessageDefinitions$MessageDefinitionCollection": { + Properties: map[string]version.PropertyVersionInfo{ + "messageDefinitions": {Public: true}, + }, + }, +} diff --git a/modelsdk/gen/metamodelversion/enums.go b/modelsdk/gen/metamodelversion/enums.go new file mode 100644 index 00000000..5813c07a --- /dev/null +++ b/modelsdk/gen/metamodelversion/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package MAX_METAMODEL_VERSION diff --git a/modelsdk/gen/metamodelversion/refs.go b/modelsdk/gen/metamodelversion/refs.go new file mode 100644 index 00000000..5813c07a --- /dev/null +++ b/modelsdk/gen/metamodelversion/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package MAX_METAMODEL_VERSION diff --git a/modelsdk/gen/metamodelversion/types.go b/modelsdk/gen/metamodelversion/types.go new file mode 100644 index 00000000..ad6d89c6 --- /dev/null +++ b/modelsdk/gen/metamodelversion/types.go @@ -0,0 +1,27 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package MAX_METAMODEL_VERSION + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +func init() { +} diff --git a/modelsdk/gen/metamodelversion/version.go b/modelsdk/gen/metamodelversion/version.go new file mode 100644 index 00000000..48fc619e --- /dev/null +++ b/modelsdk/gen/metamodelversion/version.go @@ -0,0 +1,10 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package MAX_METAMODEL_VERSION + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{} diff --git a/modelsdk/gen/microflows/enums.go b/modelsdk/gen/microflows/enums.go new file mode 100644 index 00000000..58bffe96 --- /dev/null +++ b/modelsdk/gen/microflows/enums.go @@ -0,0 +1,244 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package microflows + +// ActionActivityColor enumerates the possible values for the ActionActivityColor type. +type ActionActivityColor = string + +const ( + ActionActivityColorDefault ActionActivityColor = "Default" + ActionActivityColorBlue ActionActivityColor = "Blue" + ActionActivityColorGray ActionActivityColor = "Gray" + ActionActivityColorGreen ActionActivityColor = "Green" + ActionActivityColorLightBlue ActionActivityColor = "LightBlue" + ActionActivityColorOrange ActionActivityColor = "Orange" + ActionActivityColorPurple ActionActivityColor = "Purple" + ActionActivityColorRed ActionActivityColor = "Red" + ActionActivityColorYellow ActionActivityColor = "Yellow" +) + +// AggregateFunctionEnum enumerates the possible values for the AggregateFunctionEnum type. +type AggregateFunctionEnum = string + +const ( + AggregateFunctionEnumSum AggregateFunctionEnum = "Sum" + AggregateFunctionEnumAverage AggregateFunctionEnum = "Average" + AggregateFunctionEnumCount AggregateFunctionEnum = "Count" + AggregateFunctionEnumMinimum AggregateFunctionEnum = "Minimum" + AggregateFunctionEnumMaximum AggregateFunctionEnum = "Maximum" + AggregateFunctionEnumAll AggregateFunctionEnum = "All" + AggregateFunctionEnumAny AggregateFunctionEnum = "Any" + AggregateFunctionEnumReduce AggregateFunctionEnum = "Reduce" +) + +// ChangeActionItemType enumerates the possible values for the ChangeActionItemType type. +type ChangeActionItemType = string + +const ( + ChangeActionItemTypeSet ChangeActionItemType = "Set" + ChangeActionItemTypeAdd ChangeActionItemType = "Add" + ChangeActionItemTypeRemove ChangeActionItemType = "Remove" +) + +// ChangeListActionType enumerates the possible values for the ChangeListActionType type. +type ChangeListActionType = string + +const ( + ChangeListActionTypeSet ChangeListActionType = "Set" + ChangeListActionTypeAdd ChangeListActionType = "Add" + ChangeListActionTypeRemove ChangeListActionType = "Remove" + ChangeListActionTypeClear ChangeListActionType = "Clear" +) + +// CommitEnum enumerates the possible values for the CommitEnum type. +type CommitEnum = string + +const ( + CommitEnumYes CommitEnum = "Yes" + CommitEnumYesWithoutEvents CommitEnum = "YesWithoutEvents" + CommitEnumNo CommitEnum = "No" +) + +// ContentType enumerates the possible values for the ContentType type. +type ContentType = string + +const ( + ContentTypeXml ContentType = "Xml" + ContentTypeJson ContentType = "Json" +) + +// ErrorHandlingType enumerates the possible values for the ErrorHandlingType type. +type ErrorHandlingType = string + +const ( + ErrorHandlingTypeRollback ErrorHandlingType = "Rollback" + ErrorHandlingTypeCustom ErrorHandlingType = "Custom" + ErrorHandlingTypeCustomWithoutRollBack ErrorHandlingType = "CustomWithoutRollBack" + ErrorHandlingTypeContinue ErrorHandlingType = "Continue" + ErrorHandlingTypeAbort ErrorHandlingType = "Abort" +) + +// ErrorResultHandlingType enumerates the possible values for the ErrorResultHandlingType type. +type ErrorResultHandlingType = string + +const ( + ErrorResultHandlingTypeHttpResponse ErrorResultHandlingType = "HttpResponse" + ErrorResultHandlingTypeNone ErrorResultHandlingType = "None" +) + +// FlowLineType enumerates the possible values for the FlowLineType type. +type FlowLineType = string + +const ( + FlowLineTypeBezierCurve FlowLineType = "BezierCurve" + FlowLineTypeOrthogonal FlowLineType = "Orthogonal" +) + +// HttpMethod enumerates the possible values for the HttpMethod type. +type HttpMethod = string + +const ( + HttpMethodPost HttpMethod = "Post" + HttpMethodGet HttpMethod = "Get" + HttpMethodPut HttpMethod = "Put" + HttpMethodPatch HttpMethod = "Patch" + HttpMethodDelete HttpMethod = "Delete" +) + +// IncludedOption enumerates the possible values for the IncludedOption type. +type IncludedOption = string + +const ( + IncludedOptionYes IncludedOption = "Yes" + IncludedOptionWhenNotNull IncludedOption = "WhenNotNull" + IncludedOptionNo IncludedOption = "No" +) + +// LanguageSettingType enumerates the possible values for the LanguageSettingType type. +type LanguageSettingType = string + +const ( + LanguageSettingTypeCurrentUser LanguageSettingType = "CurrentUser" + LanguageSettingTypeProjectDefault LanguageSettingType = "ProjectDefault" + LanguageSettingTypeVariable LanguageSettingType = "Variable" +) + +// LogLevel enumerates the possible values for the LogLevel type. +type LogLevel = string + +const ( + LogLevelTrace LogLevel = "Trace" + LogLevelDebug LogLevel = "Debug" + LogLevelInfo LogLevel = "Info" + LogLevelWarning LogLevel = "Warning" + LogLevelError LogLevel = "Error" + LogLevelCritical LogLevel = "Critical" +) + +// NullValueOption enumerates the possible values for the NullValueOption type. +type NullValueOption = string + +const ( + NullValueOptionSendAsNil NullValueOption = "SendAsNil" + NullValueOptionLeaveOutElement NullValueOption = "LeaveOutElement" +) + +// ProtocolType enumerates the possible values for the ProtocolType type. +type ProtocolType = string + +const ( + ProtocolTypeUnknown ProtocolType = "Unknown" + ProtocolTypeSMTP ProtocolType = "SMTP" +) + +// RequestHandlingType enumerates the possible values for the RequestHandlingType type. +type RequestHandlingType = string + +const ( + RequestHandlingTypeMapping RequestHandlingType = "Mapping" + RequestHandlingTypeSimple RequestHandlingType = "Simple" + RequestHandlingTypeAdvanced RequestHandlingType = "Advanced" + RequestHandlingTypeBinary RequestHandlingType = "Binary" + RequestHandlingTypeCustom RequestHandlingType = "Custom" + RequestHandlingTypeFormData RequestHandlingType = "FormData" +) + +// RequestProxyType enumerates the possible values for the RequestProxyType type. +type RequestProxyType = string + +const ( + RequestProxyTypeDefaultProxy RequestProxyType = "DefaultProxy" + RequestProxyTypeOverride RequestProxyType = "Override" + RequestProxyTypeNoProxy RequestProxyType = "NoProxy" +) + +// ResultHandlingType enumerates the possible values for the ResultHandlingType type. +type ResultHandlingType = string + +const ( + ResultHandlingTypeMapping ResultHandlingType = "Mapping" + ResultHandlingTypeString ResultHandlingType = "String" + ResultHandlingTypeHttpResponse ResultHandlingType = "HttpResponse" + ResultHandlingTypeFileDocument ResultHandlingType = "FileDocument" + ResultHandlingTypeNone ResultHandlingType = "None" +) + +// SecurityType enumerates the possible values for the SecurityType type. +type SecurityType = string + +const ( + SecurityTypeNone SecurityType = "None" + SecurityTypeSSL SecurityType = "SSL" + SecurityTypeTLS SecurityType = "TLS" +) + +// ShowMessageType enumerates the possible values for the ShowMessageType type. +type ShowMessageType = string + +const ( + ShowMessageTypeInformation ShowMessageType = "Information" + ShowMessageTypeWarning ShowMessageType = "Warning" + ShowMessageTypeError ShowMessageType = "Error" +) + +// SortOrderEnum enumerates the possible values for the SortOrderEnum type. +type SortOrderEnum = string + +const ( + SortOrderEnumAscending SortOrderEnum = "Ascending" + SortOrderEnumDescending SortOrderEnum = "Descending" +) + +// SynchronizationType enumerates the possible values for the SynchronizationType type. +type SynchronizationType = string + +const ( + SynchronizationTypeAll SynchronizationType = "All" + SynchronizationTypeUnsynchronized SynchronizationType = "Unsynchronized" + SynchronizationTypeSpecific SynchronizationType = "Specific" +) + +// TargetDocumentType enumerates the possible values for the TargetDocumentType type. +type TargetDocumentType = string + +const ( + TargetDocumentTypeHTML TargetDocumentType = "HTML" + TargetDocumentTypePDF TargetDocumentType = "PDF" + TargetDocumentTypeDOCX TargetDocumentType = "DOCX" + TargetDocumentTypeDOC TargetDocumentType = "DOC" + TargetDocumentTypeRTF TargetDocumentType = "RTF" + TargetDocumentTypeODT TargetDocumentType = "ODT" +) + +// TypedTemplateArgumentType enumerates the possible values for the TypedTemplateArgumentType type. +type TypedTemplateArgumentType = string + +const ( + TypedTemplateArgumentTypeBoolean TypedTemplateArgumentType = "Boolean" + TypedTemplateArgumentTypeDateTime TypedTemplateArgumentType = "DateTime" + TypedTemplateArgumentTypeDecimal TypedTemplateArgumentType = "Decimal" + TypedTemplateArgumentTypeInteger TypedTemplateArgumentType = "Integer" + TypedTemplateArgumentTypeString TypedTemplateArgumentType = "String" +) diff --git a/modelsdk/gen/microflows/refs.go b/modelsdk/gen/microflows/refs.go new file mode 100644 index 00000000..5022e2ba --- /dev/null +++ b/modelsdk/gen/microflows/refs.go @@ -0,0 +1,234 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package microflows + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Microflows$AdditionalAttribute", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$AggregateListAction", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$AggregateAction", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$Flow", []codec.RefMeta{ + {Prop: "Origin", Kind: codec.RefById, Target: ""}, + {Prop: "Destination", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$AnnotationFlow", []codec.RefMeta{ + {Prop: "OriginPointer", Kind: codec.RefById, Target: ""}, + {Prop: "DestinationPointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$AppServiceCallAction", []codec.RefMeta{ + {Prop: "AppServiceAction", Kind: codec.RefByName, Target: "AppServices$AppServiceAction"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$AppServiceCallParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "AppServices$AppServiceActionParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$AssociationRetrieveSource", []codec.RefMeta{ + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$AuthenticationDocumentConfig", []codec.RefMeta{ + {Prop: "AuthenticationDocument", Kind: codec.RefByName, Target: "Authentication$Authentication"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$CallExternalAction", []codec.RefMeta{ + {Prop: "ConsumedODataService", Kind: codec.RefByName, Target: "Rest$ConsumedODataService"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$ClearFromClientAction", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$CreateListAction", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$CreateObjectAction", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$CreateChangeAction", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$CustomBlobDocumentCodeActionParameterValue", []codec.RefMeta{ + {Prop: "CustomDocument", Kind: codec.RefByName, Target: "CustomBlobDocuments$CustomBlobDocument"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$DatabaseRetrieveSource", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$EmailMessage", []codec.RefMeta{ + {Prop: "Attachments", Kind: codec.RefByNameList, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$EntityTypeCodeActionParameterValue", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$EntityTypeJavaActionParameterValue", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$ExportMappingJavaActionParameterValue", []codec.RefMeta{ + {Prop: "ExportMapping", Kind: codec.RefByName, Target: "ExportMappings$ExportMapping"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$ExportMappingParameterValue", []codec.RefMeta{ + {Prop: "ExportMapping", Kind: codec.RefByName, Target: "ExportMappings$ExportMapping"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$ExportXmlAction", []codec.RefMeta{ + {Prop: "Mapping", Kind: codec.RefByName, Target: "ExportMappings$ExportMapping"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$InspectAttribute", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$Filter", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$Find", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$GenerateDocumentAction", []codec.RefMeta{ + {Prop: "DocumentTemplate", Kind: codec.RefByName, Target: "DocumentTemplates$DocumentTemplate"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$GenerateJumpToOptionsAction", []codec.RefMeta{ + {Prop: "Workflow", Kind: codec.RefByName, Target: "Workflows$Workflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$GetWorkflowDataAction", []codec.RefMeta{ + {Prop: "Workflow", Kind: codec.RefByName, Target: "Workflows$Workflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$ImportMappingCall", []codec.RefMeta{ + {Prop: "Mapping", Kind: codec.RefByName, Target: "ImportMappings$ImportMapping"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$ImportMappingJavaActionParameterValue", []codec.RefMeta{ + {Prop: "ImportMapping", Kind: codec.RefByName, Target: "ImportMappings$ImportMapping"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$ImportMappingParameterValue", []codec.RefMeta{ + {Prop: "ImportMapping", Kind: codec.RefByName, Target: "ImportMappings$ImportMapping"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$IncludedAssociation", []codec.RefMeta{ + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$InheritanceCase", []codec.RefMeta{ + {Prop: "Value", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$JavaActionCallAction", []codec.RefMeta{ + {Prop: "JavaAction", Kind: codec.RefByName, Target: "JavaActions$JavaAction"}, + {Prop: "Queue", Kind: codec.RefByName, Target: "Queues$Queue"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$JavaActionParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "JavaActions$JavaActionParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$JavaScriptActionCallAction", []codec.RefMeta{ + {Prop: "JavaScriptAction", Kind: codec.RefByName, Target: "JavaScriptActions$JavaScriptAction"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$JavaScriptActionParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "JavaScriptActions$JavaScriptActionParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$LockWorkflowAction", []codec.RefMeta{ + {Prop: "Workflow", Kind: codec.RefByName, Target: "Workflows$Workflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$MLModelCall", []codec.RefMeta{ + {Prop: "MlMappingDocument", Kind: codec.RefByName, Target: "MLMappings$MLMappingDocument"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$MLModelCallAction", []codec.RefMeta{ + {Prop: "MlMappingDocument", Kind: codec.RefByName, Target: "MLMappings$MLMappingDocument"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$MappingRequestHandling", []codec.RefMeta{ + {Prop: "Mapping", Kind: codec.RefByName, Target: "ExportMappings$ExportMapping"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$MemberChange", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$ChangeActionItem", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$Microflow", []codec.RefMeta{ + {Prop: "AllowedModuleRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + {Prop: "ConcurrencyErrorMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "UrlSearchParameters", Kind: codec.RefByNameList, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$MicroflowCall", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "Queue", Kind: codec.RefByName, Target: "Queues$Queue"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$MicroflowCallParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Mappings$MicroflowCallParameterMappingImpl", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$MicroflowJavaActionParameterValue", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$MicroflowParameterAttributeUrlSegment", []codec.RefMeta{ + {Prop: "MicroflowParameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$MicroflowParameterValue", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$MicroflowPrimitiveParameterUrlSegment", []codec.RefMeta{ + {Prop: "MicroflowParameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$Nanoflow", []codec.RefMeta{ + {Prop: "AllowedModuleRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$NanoflowCall", []codec.RefMeta{ + {Prop: "Nanoflow", Kind: codec.RefByName, Target: "Microflows$Nanoflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$NanoflowCallParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Microflows$NanoflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$NotifyWorkflowAction", []codec.RefMeta{ + {Prop: "Activity", Kind: codec.RefByName, Target: "Workflows$WaitForNotificationActivity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$ParameterIdUrlSegment", []codec.RefMeta{ + {Prop: "MicroflowParameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$QueryParameterMapping", []codec.RefMeta{ + {Prop: "QueryParameter", Kind: codec.RefByName, Target: "Rest$QueryParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$RestOperationCallAction", []codec.RefMeta{ + {Prop: "Operation", Kind: codec.RefByName, Target: "Rest$RestOperation"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$RestOperationParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Rest$OperationParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$RestParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Rest$RestParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$RuleCall", []codec.RefMeta{ + {Prop: "Rule", Kind: codec.RefByName, Target: "Microflows$Rule"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$RuleCallParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Microflows$RuleParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$SequenceFlow", []codec.RefMeta{ + {Prop: "OriginPointer", Kind: codec.RefById, Target: ""}, + {Prop: "DestinationPointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$SetTaskOutcomeAction", []codec.RefMeta{ + {Prop: "Outcome", Kind: codec.RefByName, Target: "Workflows$UserTaskOutcome"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$TransformJsonAction", []codec.RefMeta{ + {Prop: "Transformation", Kind: codec.RefByName, Target: "DataTransformers$DataTransformer"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$UnlockWorkflowAction", []codec.RefMeta{ + {Prop: "Workflow", Kind: codec.RefByName, Target: "Workflows$Workflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$ValidationFeedbackAction", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$WebServiceCallAction", []codec.RefMeta{ + {Prop: "ImportedWebService", Kind: codec.RefByName, Target: "WebServices$ImportedWebService"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$WebServiceOperationAdvancedParameterMapping", []codec.RefMeta{ + {Prop: "Mapping", Kind: codec.RefByName, Target: "ExportMappings$ExportMapping"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Microflows$WorkflowCallAction", []codec.RefMeta{ + {Prop: "Workflow", Kind: codec.RefByName, Target: "Workflows$Workflow"}, + }) +} diff --git a/modelsdk/gen/microflows/types.go b/modelsdk/gen/microflows/types.go new file mode 100644 index 00000000..978f86d7 --- /dev/null +++ b/modelsdk/gen/microflows/types.go @@ -0,0 +1,17105 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package microflows + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// WorkflowOperation +// ──────────────────────────────────────────────────────── + +type WorkflowOperation struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowOperation) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// AbortOperation +// ──────────────────────────────────────────────────────── + +type AbortOperation struct { + element.Base + workflowVariable *property.Primitive[string] + reason *property.Part[element.Element] +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *AbortOperation) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *AbortOperation) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// Reason returns the value of the reason property. +func (o *AbortOperation) Reason() element.Element { + return o.reason.Get() +} + +// SetReason sets the value of the reason property. +func (o *AbortOperation) SetReason(v element.Element) { + o.reason.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AbortOperation) InitFromRaw(raw bson.Raw) { + o.workflowVariable.Init(raw) + if child, err := codec.DecodeChild(raw, "Reason"); err == nil { + o.reason.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowObject +// ──────────────────────────────────────────────────────── + +type MicroflowObject struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *MicroflowObject) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *MicroflowObject) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *MicroflowObject) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *MicroflowObject) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowObject) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Activity +// ──────────────────────────────────────────────────────── + +type Activity struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *Activity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *Activity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *Activity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *Activity) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Activity) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ActionActivity +// ──────────────────────────────────────────────────────── + +type ActionActivity struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + action *property.Part[element.Element] + disabled *property.Primitive[bool] + caption *property.Primitive[string] + autoGenerateCaption *property.Primitive[bool] + backgroundColor *property.Enum[string] + documentation *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *ActionActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *ActionActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *ActionActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *ActionActivity) SetSize(v string) { + o.size.Set(v) +} + +// Action returns the value of the action property. +func (o *ActionActivity) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *ActionActivity) SetAction(v element.Element) { + o.action.Set(v) +} + +// Disabled returns the value of the disabled property. +func (o *ActionActivity) Disabled() bool { + return o.disabled.Get() +} + +// SetDisabled sets the value of the disabled property. +func (o *ActionActivity) SetDisabled(v bool) { + o.disabled.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ActionActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ActionActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// AutoGenerateCaption returns the value of the autoGenerateCaption property. +func (o *ActionActivity) AutoGenerateCaption() bool { + return o.autoGenerateCaption.Get() +} + +// SetAutoGenerateCaption sets the value of the autoGenerateCaption property. +func (o *ActionActivity) SetAutoGenerateCaption(v bool) { + o.autoGenerateCaption.Set(v) +} + +// BackgroundColor returns the value of the backgroundColor property. +func (o *ActionActivity) BackgroundColor() string { + return o.backgroundColor.Get() +} + +// SetBackgroundColor sets the value of the backgroundColor property. +func (o *ActionActivity) SetBackgroundColor(v string) { + o.backgroundColor.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ActionActivity) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ActionActivity) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ActionActivity) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } + o.disabled.Init(raw) + o.caption.Init(raw) + o.autoGenerateCaption.Init(raw) + if val, err := raw.LookupErr("BackgroundColor"); err == nil { + if s, ok := val.StringValueOK(); ok { o.backgroundColor.SetFromDecode(s) } + } + o.documentation.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// AdditionalAttribute +// ──────────────────────────────────────────────────────── + +type AdditionalAttribute struct { + element.Base + name *property.Primitive[string] + propType *property.Part[element.Element] + value *property.Primitive[string] + attribute *property.ByNameRef[element.Element] + attributeDataType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *AdditionalAttribute) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *AdditionalAttribute) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *AdditionalAttribute) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *AdditionalAttribute) SetType(v element.Element) { + o.propType.Set(v) +} + +// Value returns the value of the value property. +func (o *AdditionalAttribute) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *AdditionalAttribute) SetValue(v string) { + o.value.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *AdditionalAttribute) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *AdditionalAttribute) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// AttributeDataType returns the value of the attributeDataType property. +func (o *AdditionalAttribute) AttributeDataType() element.Element { + return o.attributeDataType.Get() +} + +// SetAttributeDataType sets the value of the attributeDataType property. +func (o *AdditionalAttribute) SetAttributeDataType(v element.Element) { + o.attributeDataType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AdditionalAttribute) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } + o.value.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "AttributeDataType"); err == nil { + o.attributeDataType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// RequestHandling +// ──────────────────────────────────────────────────────── + +type RequestHandling struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RequestHandling) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// AdvancedRequestHandling +// ──────────────────────────────────────────────────────── + +type AdvancedRequestHandling struct { + element.Base + parameterMappings *property.PartList[element.Element] + nullValueOption *property.Enum[string] +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *AdvancedRequestHandling) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *AdvancedRequestHandling) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *AdvancedRequestHandling) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// NullValueOption returns the value of the nullValueOption property. +func (o *AdvancedRequestHandling) NullValueOption() string { + return o.nullValueOption.Get() +} + +// SetNullValueOption sets the value of the nullValueOption property. +func (o *AdvancedRequestHandling) SetNullValueOption(v string) { + o.nullValueOption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AdvancedRequestHandling) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("NullValueOption"); err == nil { + if s, ok := val.StringValueOK(); ok { o.nullValueOption.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowAction +// ──────────────────────────────────────────────────────── + +type MicroflowAction struct { + element.Base + errorHandlingType *property.Enum[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *MicroflowAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *MicroflowAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// AggregateListAction +// ──────────────────────────────────────────────────────── + +type AggregateListAction struct { + element.Base + errorHandlingType *property.Enum[string] + inputListVariableName *property.Primitive[string] + attribute *property.ByNameRef[element.Element] + expression *property.Primitive[string] + useExpression *property.Primitive[bool] + aggregateFunction *property.Enum[string] + outputVariableName *property.Primitive[string] + reduceReturnDataType *property.Part[element.Element] + reduceInitialValueExpression *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *AggregateListAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *AggregateListAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// InputListVariableName returns the value of the inputListVariableName property. +func (o *AggregateListAction) InputListVariableName() string { + return o.inputListVariableName.Get() +} + +// SetInputListVariableName sets the value of the inputListVariableName property. +func (o *AggregateListAction) SetInputListVariableName(v string) { + o.inputListVariableName.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *AggregateListAction) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *AggregateListAction) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// Expression returns the value of the expression property. +func (o *AggregateListAction) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *AggregateListAction) SetExpression(v string) { + o.expression.Set(v) +} + +// UseExpression returns the value of the useExpression property. +func (o *AggregateListAction) UseExpression() bool { + return o.useExpression.Get() +} + +// SetUseExpression sets the value of the useExpression property. +func (o *AggregateListAction) SetUseExpression(v bool) { + o.useExpression.Set(v) +} + +// AggregateFunction returns the value of the aggregateFunction property. +func (o *AggregateListAction) AggregateFunction() string { + return o.aggregateFunction.Get() +} + +// SetAggregateFunction sets the value of the aggregateFunction property. +func (o *AggregateListAction) SetAggregateFunction(v string) { + o.aggregateFunction.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *AggregateListAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *AggregateListAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// ReduceReturnDataType returns the value of the reduceReturnDataType property. +func (o *AggregateListAction) ReduceReturnDataType() element.Element { + return o.reduceReturnDataType.Get() +} + +// SetReduceReturnDataType sets the value of the reduceReturnDataType property. +func (o *AggregateListAction) SetReduceReturnDataType(v element.Element) { + o.reduceReturnDataType.Set(v) +} + +// ReduceInitialValueExpression returns the value of the reduceInitialValueExpression property. +func (o *AggregateListAction) ReduceInitialValueExpression() string { + return o.reduceInitialValueExpression.Get() +} + +// SetReduceInitialValueExpression sets the value of the reduceInitialValueExpression property. +func (o *AggregateListAction) SetReduceInitialValueExpression(v string) { + o.reduceInitialValueExpression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AggregateListAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.inputListVariableName.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + o.expression.Init(raw) + o.useExpression.Init(raw) + if val, err := raw.LookupErr("AggregateFunction"); err == nil { + if s, ok := val.StringValueOK(); ok { o.aggregateFunction.SetFromDecode(s) } + } + o.outputVariableName.Init(raw) + if child, err := codec.DecodeChild(raw, "ReduceReturnDataType"); err == nil { + o.reduceReturnDataType.SetFromDecode(child) + } + o.reduceInitialValueExpression.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Annotation +// ──────────────────────────────────────────────────────── + +type Annotation struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + caption *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *Annotation) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *Annotation) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *Annotation) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *Annotation) SetSize(v string) { + o.size.Set(v) +} + +// Caption returns the value of the caption property. +func (o *Annotation) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *Annotation) SetCaption(v string) { + o.caption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Annotation) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + o.caption.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Flow +// ──────────────────────────────────────────────────────── + +type Flow struct { + element.Base + origin *property.ByIdRef[element.Element] + destination *property.ByIdRef[element.Element] + originConnectionIndex *property.Primitive[int32] + destinationConnectionIndex *property.Primitive[int32] + originBezierVector *property.Primitive[string] + destinationBezierVector *property.Primitive[string] + lineType *property.Enum[string] + line *property.Part[element.Element] +} + +// OriginRefID returns the value of the origin property. +func (o *Flow) OriginRefID() element.ID { + return o.origin.RefID() +} + +// SetOriginID sets the value of the origin property. +func (o *Flow) SetOriginID(v element.ID) { + o.origin.SetID(v) +} + +// DestinationRefID returns the value of the destination property. +func (o *Flow) DestinationRefID() element.ID { + return o.destination.RefID() +} + +// SetDestinationID sets the value of the destination property. +func (o *Flow) SetDestinationID(v element.ID) { + o.destination.SetID(v) +} + +// OriginConnectionIndex returns the value of the originConnectionIndex property. +func (o *Flow) OriginConnectionIndex() int32 { + return o.originConnectionIndex.Get() +} + +// SetOriginConnectionIndex sets the value of the originConnectionIndex property. +func (o *Flow) SetOriginConnectionIndex(v int32) { + o.originConnectionIndex.Set(v) +} + +// DestinationConnectionIndex returns the value of the destinationConnectionIndex property. +func (o *Flow) DestinationConnectionIndex() int32 { + return o.destinationConnectionIndex.Get() +} + +// SetDestinationConnectionIndex sets the value of the destinationConnectionIndex property. +func (o *Flow) SetDestinationConnectionIndex(v int32) { + o.destinationConnectionIndex.Set(v) +} + +// OriginBezierVector returns the value of the originBezierVector property. +func (o *Flow) OriginBezierVector() string { + return o.originBezierVector.Get() +} + +// SetOriginBezierVector sets the value of the originBezierVector property. +func (o *Flow) SetOriginBezierVector(v string) { + o.originBezierVector.Set(v) +} + +// DestinationBezierVector returns the value of the destinationBezierVector property. +func (o *Flow) DestinationBezierVector() string { + return o.destinationBezierVector.Get() +} + +// SetDestinationBezierVector sets the value of the destinationBezierVector property. +func (o *Flow) SetDestinationBezierVector(v string) { + o.destinationBezierVector.Set(v) +} + +// LineType returns the value of the lineType property. +func (o *Flow) LineType() string { + return o.lineType.Get() +} + +// SetLineType sets the value of the lineType property. +func (o *Flow) SetLineType(v string) { + o.lineType.Set(v) +} + +// Line returns the value of the line property. +func (o *Flow) Line() element.Element { + return o.line.Get() +} + +// SetLine sets the value of the line property. +func (o *Flow) SetLine(v element.Element) { + o.line.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Flow) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Origin"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.origin.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.origin.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + if val, err := raw.LookupErr("Destination"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.destination.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.destination.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.originConnectionIndex.Init(raw) + o.destinationConnectionIndex.Init(raw) + o.originBezierVector.Init(raw) + o.destinationBezierVector.Init(raw) + if val, err := raw.LookupErr("LineType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.lineType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Line"); err == nil { + o.line.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// AnnotationFlow +// ──────────────────────────────────────────────────────── + +type AnnotationFlow struct { + element.Base + origin *property.ByIdRef[element.Element] + destination *property.ByIdRef[element.Element] + originConnectionIndex *property.Primitive[int32] + destinationConnectionIndex *property.Primitive[int32] + originBezierVector *property.Primitive[string] + destinationBezierVector *property.Primitive[string] + lineType *property.Enum[string] + line *property.Part[element.Element] +} + +// OriginRefID returns the value of the origin property. +func (o *AnnotationFlow) OriginRefID() element.ID { + return o.origin.RefID() +} + +// SetOriginID sets the value of the origin property. +func (o *AnnotationFlow) SetOriginID(v element.ID) { + o.origin.SetID(v) +} + +// DestinationRefID returns the value of the destination property. +func (o *AnnotationFlow) DestinationRefID() element.ID { + return o.destination.RefID() +} + +// SetDestinationID sets the value of the destination property. +func (o *AnnotationFlow) SetDestinationID(v element.ID) { + o.destination.SetID(v) +} + +// OriginConnectionIndex returns the value of the originConnectionIndex property. +func (o *AnnotationFlow) OriginConnectionIndex() int32 { + return o.originConnectionIndex.Get() +} + +// SetOriginConnectionIndex sets the value of the originConnectionIndex property. +func (o *AnnotationFlow) SetOriginConnectionIndex(v int32) { + o.originConnectionIndex.Set(v) +} + +// DestinationConnectionIndex returns the value of the destinationConnectionIndex property. +func (o *AnnotationFlow) DestinationConnectionIndex() int32 { + return o.destinationConnectionIndex.Get() +} + +// SetDestinationConnectionIndex sets the value of the destinationConnectionIndex property. +func (o *AnnotationFlow) SetDestinationConnectionIndex(v int32) { + o.destinationConnectionIndex.Set(v) +} + +// OriginBezierVector returns the value of the originBezierVector property. +func (o *AnnotationFlow) OriginBezierVector() string { + return o.originBezierVector.Get() +} + +// SetOriginBezierVector sets the value of the originBezierVector property. +func (o *AnnotationFlow) SetOriginBezierVector(v string) { + o.originBezierVector.Set(v) +} + +// DestinationBezierVector returns the value of the destinationBezierVector property. +func (o *AnnotationFlow) DestinationBezierVector() string { + return o.destinationBezierVector.Get() +} + +// SetDestinationBezierVector sets the value of the destinationBezierVector property. +func (o *AnnotationFlow) SetDestinationBezierVector(v string) { + o.destinationBezierVector.Set(v) +} + +// LineType returns the value of the lineType property. +func (o *AnnotationFlow) LineType() string { + return o.lineType.Get() +} + +// SetLineType sets the value of the lineType property. +func (o *AnnotationFlow) SetLineType(v string) { + o.lineType.Set(v) +} + +// Line returns the value of the line property. +func (o *AnnotationFlow) Line() element.Element { + return o.line.Get() +} + +// SetLine sets the value of the line property. +func (o *AnnotationFlow) SetLine(v element.Element) { + o.line.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AnnotationFlow) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("OriginPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.origin.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.origin.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + if val, err := raw.LookupErr("DestinationPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.destination.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.destination.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.originConnectionIndex.Init(raw) + o.destinationConnectionIndex.Init(raw) + o.originBezierVector.Init(raw) + o.destinationBezierVector.Init(raw) + if val, err := raw.LookupErr("LineType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.lineType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Line"); err == nil { + o.line.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// AppServiceCallAction +// ──────────────────────────────────────────────────────── + +type AppServiceCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + appServiceAction *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] + useVariable *property.Primitive[bool] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *AppServiceCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *AppServiceCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// AppServiceActionQualifiedName returns the value of the appServiceAction property. +func (o *AppServiceCallAction) AppServiceActionQualifiedName() string { + return o.appServiceAction.QualifiedName() +} + +// SetAppServiceActionQualifiedName sets the value of the appServiceAction property. +func (o *AppServiceCallAction) SetAppServiceActionQualifiedName(v string) { + o.appServiceAction.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *AppServiceCallAction) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *AppServiceCallAction) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *AppServiceCallAction) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// UseVariable returns the value of the useVariable property. +func (o *AppServiceCallAction) UseVariable() bool { + return o.useVariable.Get() +} + +// SetUseVariable sets the value of the useVariable property. +func (o *AppServiceCallAction) SetUseVariable(v bool) { + o.useVariable.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *AppServiceCallAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *AppServiceCallAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AppServiceCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("AppServiceAction"); err == nil { + if s, ok := val.StringValueOK(); ok { o.appServiceAction.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + o.useVariable.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// AppServiceCallParameterMapping +// ──────────────────────────────────────────────────────── + +type AppServiceCallParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + argument *property.Primitive[string] + argumentModel *property.Part[element.Element] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *AppServiceCallParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *AppServiceCallParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Argument returns the value of the argument property. +func (o *AppServiceCallParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *AppServiceCallParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// ArgumentModel returns the value of the argumentModel property. +func (o *AppServiceCallParameterMapping) ArgumentModel() element.Element { + return o.argumentModel.Get() +} + +// SetArgumentModel sets the value of the argumentModel property. +func (o *AppServiceCallParameterMapping) SetArgumentModel(v element.Element) { + o.argumentModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AppServiceCallParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "ArgumentModel"); err == nil { + o.argumentModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ApplyJumpToOptionAction +// ──────────────────────────────────────────────────────── + +type ApplyJumpToOptionAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflowJumpToDetailsVariable *property.Primitive[string] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ApplyJumpToOptionAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ApplyJumpToOptionAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowJumpToDetailsVariable returns the value of the workflowJumpToDetailsVariable property. +func (o *ApplyJumpToOptionAction) WorkflowJumpToDetailsVariable() string { + return o.workflowJumpToDetailsVariable.Get() +} + +// SetWorkflowJumpToDetailsVariable sets the value of the workflowJumpToDetailsVariable property. +func (o *ApplyJumpToOptionAction) SetWorkflowJumpToDetailsVariable(v string) { + o.workflowJumpToDetailsVariable.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *ApplyJumpToOptionAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *ApplyJumpToOptionAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ApplyJumpToOptionAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.workflowJumpToDetailsVariable.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RetrieveSource +// ──────────────────────────────────────────────────────── + +type RetrieveSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RetrieveSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// AssociationRetrieveSource +// ──────────────────────────────────────────────────────── + +type AssociationRetrieveSource struct { + element.Base + startVariableName *property.Primitive[string] + association *property.ByNameRef[element.Element] +} + +// StartVariableName returns the value of the startVariableName property. +func (o *AssociationRetrieveSource) StartVariableName() string { + return o.startVariableName.Get() +} + +// SetStartVariableName sets the value of the startVariableName property. +func (o *AssociationRetrieveSource) SetStartVariableName(v string) { + o.startVariableName.Set(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *AssociationRetrieveSource) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *AssociationRetrieveSource) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AssociationRetrieveSource) InitFromRaw(raw bson.Raw) { + o.startVariableName.Init(raw) + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { o.association.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// AuthenticationConfig +// ──────────────────────────────────────────────────────── + +type AuthenticationConfig struct { + element.Base + optForAuthDocument *property.Primitive[bool] +} + +// OptForAuthDocument returns the value of the optForAuthDocument property. +func (o *AuthenticationConfig) OptForAuthDocument() bool { + return o.optForAuthDocument.Get() +} + +// SetOptForAuthDocument sets the value of the optForAuthDocument property. +func (o *AuthenticationConfig) SetOptForAuthDocument(v bool) { + o.optForAuthDocument.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AuthenticationConfig) InitFromRaw(raw bson.Raw) { + o.optForAuthDocument.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// AuthenticationDocumentConfig +// ──────────────────────────────────────────────────────── + +type AuthenticationDocumentConfig struct { + element.Base + optForAuthDocument *property.Primitive[bool] + authenticationDocument *property.ByNameRef[element.Element] +} + +// OptForAuthDocument returns the value of the optForAuthDocument property. +func (o *AuthenticationDocumentConfig) OptForAuthDocument() bool { + return o.optForAuthDocument.Get() +} + +// SetOptForAuthDocument sets the value of the optForAuthDocument property. +func (o *AuthenticationDocumentConfig) SetOptForAuthDocument(v bool) { + o.optForAuthDocument.Set(v) +} + +// AuthenticationDocumentQualifiedName returns the value of the authenticationDocument property. +func (o *AuthenticationDocumentConfig) AuthenticationDocumentQualifiedName() string { + return o.authenticationDocument.QualifiedName() +} + +// SetAuthenticationDocumentQualifiedName sets the value of the authenticationDocument property. +func (o *AuthenticationDocumentConfig) SetAuthenticationDocumentQualifiedName(v string) { + o.authenticationDocument.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AuthenticationDocumentConfig) InitFromRaw(raw bson.Raw) { + o.optForAuthDocument.Init(raw) + if val, err := raw.LookupErr("AuthenticationDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { o.authenticationDocument.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// BasicAuthConfig +// ──────────────────────────────────────────────────────── + +type BasicAuthConfig struct { + element.Base + optForAuthDocument *property.Primitive[bool] + username *property.Primitive[string] + password *property.Primitive[string] +} + +// OptForAuthDocument returns the value of the optForAuthDocument property. +func (o *BasicAuthConfig) OptForAuthDocument() bool { + return o.optForAuthDocument.Get() +} + +// SetOptForAuthDocument sets the value of the optForAuthDocument property. +func (o *BasicAuthConfig) SetOptForAuthDocument(v bool) { + o.optForAuthDocument.Set(v) +} + +// Username returns the value of the username property. +func (o *BasicAuthConfig) Username() string { + return o.username.Get() +} + +// SetUsername sets the value of the username property. +func (o *BasicAuthConfig) SetUsername(v string) { + o.username.Set(v) +} + +// Password returns the value of the password property. +func (o *BasicAuthConfig) Password() string { + return o.password.Get() +} + +// SetPassword sets the value of the password property. +func (o *BasicAuthConfig) SetPassword(v string) { + o.password.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicAuthConfig) InitFromRaw(raw bson.Raw) { + o.optForAuthDocument.Init(raw) + o.username.Init(raw) + o.password.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CodeActionParameterValue +// ──────────────────────────────────────────────────────── + +type CodeActionParameterValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CodeActionParameterValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ExpressionBasedCodeActionParameterValue +// ──────────────────────────────────────────────────────── + +type ExpressionBasedCodeActionParameterValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExpressionBasedCodeActionParameterValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BasicCodeActionParameterValue +// ──────────────────────────────────────────────────────── + +type BasicCodeActionParameterValue struct { + element.Base + argument *property.Primitive[string] + argumentModel *property.Part[element.Element] +} + +// Argument returns the value of the argument property. +func (o *BasicCodeActionParameterValue) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *BasicCodeActionParameterValue) SetArgument(v string) { + o.argument.Set(v) +} + +// ArgumentModel returns the value of the argumentModel property. +func (o *BasicCodeActionParameterValue) ArgumentModel() element.Element { + return o.argumentModel.Get() +} + +// SetArgumentModel sets the value of the argumentModel property. +func (o *BasicCodeActionParameterValue) SetArgumentModel(v element.Element) { + o.argumentModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicCodeActionParameterValue) InitFromRaw(raw bson.Raw) { + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "ArgumentModel"); err == nil { + o.argumentModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// JavaActionParameterValue +// ──────────────────────────────────────────────────────── + +type JavaActionParameterValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaActionParameterValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BasicJavaActionParameterValue +// ──────────────────────────────────────────────────────── + +type BasicJavaActionParameterValue struct { + element.Base + argument *property.Primitive[string] + argumentModel *property.Part[element.Element] +} + +// Argument returns the value of the argument property. +func (o *BasicJavaActionParameterValue) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *BasicJavaActionParameterValue) SetArgument(v string) { + o.argument.Set(v) +} + +// ArgumentModel returns the value of the argumentModel property. +func (o *BasicJavaActionParameterValue) ArgumentModel() element.Element { + return o.argumentModel.Get() +} + +// SetArgumentModel sets the value of the argumentModel property. +func (o *BasicJavaActionParameterValue) SetArgumentModel(v element.Element) { + o.argumentModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicJavaActionParameterValue) InitFromRaw(raw bson.Raw) { + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "ArgumentModel"); err == nil { + o.argumentModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Line +// ──────────────────────────────────────────────────────── + +type Line struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Line) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BezierCurve +// ──────────────────────────────────────────────────────── + +type BezierCurve struct { + element.Base + originControlVector *property.Primitive[string] + destinationControlVector *property.Primitive[string] +} + +// OriginControlVector returns the value of the originControlVector property. +func (o *BezierCurve) OriginControlVector() string { + return o.originControlVector.Get() +} + +// SetOriginControlVector sets the value of the originControlVector property. +func (o *BezierCurve) SetOriginControlVector(v string) { + o.originControlVector.Set(v) +} + +// DestinationControlVector returns the value of the destinationControlVector property. +func (o *BezierCurve) DestinationControlVector() string { + return o.destinationControlVector.Get() +} + +// SetDestinationControlVector sets the value of the destinationControlVector property. +func (o *BezierCurve) SetDestinationControlVector(v string) { + o.destinationControlVector.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BezierCurve) InitFromRaw(raw bson.Raw) { + o.originControlVector.Init(raw) + o.destinationControlVector.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ListOperation +// ──────────────────────────────────────────────────────── + +type ListOperation struct { + element.Base + listVariableName *property.Primitive[string] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *ListOperation) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *ListOperation) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListOperation) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// BinaryListOperation +// ──────────────────────────────────────────────────────── + +type BinaryListOperation struct { + element.Base + listVariableName *property.Primitive[string] + secondListOrObjectVariableName *property.Primitive[string] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *BinaryListOperation) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *BinaryListOperation) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// SecondListOrObjectVariableName returns the value of the secondListOrObjectVariableName property. +func (o *BinaryListOperation) SecondListOrObjectVariableName() string { + return o.secondListOrObjectVariableName.Get() +} + +// SetSecondListOrObjectVariableName sets the value of the secondListOrObjectVariableName property. +func (o *BinaryListOperation) SetSecondListOrObjectVariableName(v string) { + o.secondListOrObjectVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BinaryListOperation) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.secondListOrObjectVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// BinaryRequestHandling +// ──────────────────────────────────────────────────────── + +type BinaryRequestHandling struct { + element.Base + expression *property.Primitive[string] + expressionModel *property.Part[element.Element] +} + +// Expression returns the value of the expression property. +func (o *BinaryRequestHandling) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *BinaryRequestHandling) SetExpression(v string) { + o.expression.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *BinaryRequestHandling) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *BinaryRequestHandling) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BinaryRequestHandling) InitFromRaw(raw bson.Raw) { + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// BodyVariable +// ──────────────────────────────────────────────────────── + +type BodyVariable struct { + element.Base + variableName *property.Primitive[string] +} + +// VariableName returns the value of the variableName property. +func (o *BodyVariable) VariableName() string { + return o.variableName.Get() +} + +// SetVariableName sets the value of the variableName property. +func (o *BodyVariable) SetVariableName(v string) { + o.variableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BodyVariable) InitFromRaw(raw bson.Raw) { + o.variableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// BreakEvent +// ──────────────────────────────────────────────────────── + +type BreakEvent struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *BreakEvent) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *BreakEvent) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *BreakEvent) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *BreakEvent) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BreakEvent) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CallExternalAction +// ──────────────────────────────────────────────────────── + +type CallExternalAction struct { + element.Base + errorHandlingType *property.Enum[string] + consumedODataService *property.ByNameRef[element.Element] + name *property.Primitive[string] + parameterMappings *property.PartList[element.Element] + variableName *property.Primitive[string] + variableDataType *property.Part[element.Element] + includedAssociations *property.PartList[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *CallExternalAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *CallExternalAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// ConsumedODataServiceQualifiedName returns the value of the consumedODataService property. +func (o *CallExternalAction) ConsumedODataServiceQualifiedName() string { + return o.consumedODataService.QualifiedName() +} + +// SetConsumedODataServiceQualifiedName sets the value of the consumedODataService property. +func (o *CallExternalAction) SetConsumedODataServiceQualifiedName(v string) { + o.consumedODataService.SetQualifiedName(v) +} + +// Name returns the value of the name property. +func (o *CallExternalAction) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CallExternalAction) SetName(v string) { + o.name.Set(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *CallExternalAction) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *CallExternalAction) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *CallExternalAction) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// VariableName returns the value of the variableName property. +func (o *CallExternalAction) VariableName() string { + return o.variableName.Get() +} + +// SetVariableName sets the value of the variableName property. +func (o *CallExternalAction) SetVariableName(v string) { + o.variableName.Set(v) +} + +// VariableDataType returns the value of the variableDataType property. +func (o *CallExternalAction) VariableDataType() element.Element { + return o.variableDataType.Get() +} + +// SetVariableDataType sets the value of the variableDataType property. +func (o *CallExternalAction) SetVariableDataType(v element.Element) { + o.variableDataType.Set(v) +} + +// IncludedAssociationsItems returns the value of the includedAssociations property. +func (o *CallExternalAction) IncludedAssociationsItems() []element.Element { + return o.includedAssociations.Items() +} + +// AddIncludedAssociations appends a child element to the includedAssociations list. +func (o *CallExternalAction) AddIncludedAssociations(v element.Element) { + o.includedAssociations.Append(v) +} + +// RemoveIncludedAssociations removes the element at the given index from the includedAssociations list. +func (o *CallExternalAction) RemoveIncludedAssociations(index int) { + o.includedAssociations.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CallExternalAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ConsumedODataService"); err == nil { + if s, ok := val.StringValueOK(); ok { o.consumedODataService.SetFromDecode(s) } + } + o.name.Init(raw) + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + o.variableName.Init(raw) + if child, err := codec.DecodeChild(raw, "VariableDataType"); err == nil { + o.variableDataType.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "IncludedAssociations"); err == nil { + for _, child := range children { + o.includedAssociations.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// CancelSynchronizationAction +// ──────────────────────────────────────────────────────── + +type CancelSynchronizationAction struct { + element.Base + errorHandlingType *property.Enum[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *CancelSynchronizationAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *CancelSynchronizationAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CancelSynchronizationAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// CaseValue +// ──────────────────────────────────────────────────────── + +type CaseValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CaseValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CastAction +// ──────────────────────────────────────────────────────── + +type CastAction struct { + element.Base + errorHandlingType *property.Enum[string] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *CastAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *CastAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *CastAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *CastAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CastAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ChangeListAction +// ──────────────────────────────────────────────────────── + +type ChangeListAction struct { + element.Base + errorHandlingType *property.Enum[string] + changeVariableName *property.Primitive[string] + value *property.Primitive[string] + valueModel *property.Part[element.Element] + propType *property.Enum[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ChangeListAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ChangeListAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// ChangeVariableName returns the value of the changeVariableName property. +func (o *ChangeListAction) ChangeVariableName() string { + return o.changeVariableName.Get() +} + +// SetChangeVariableName sets the value of the changeVariableName property. +func (o *ChangeListAction) SetChangeVariableName(v string) { + o.changeVariableName.Set(v) +} + +// Value returns the value of the value property. +func (o *ChangeListAction) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *ChangeListAction) SetValue(v string) { + o.value.Set(v) +} + +// ValueModel returns the value of the valueModel property. +func (o *ChangeListAction) ValueModel() element.Element { + return o.valueModel.Get() +} + +// SetValueModel sets the value of the valueModel property. +func (o *ChangeListAction) SetValueModel(v element.Element) { + o.valueModel.Set(v) +} + +// Type returns the value of the type property. +func (o *ChangeListAction) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *ChangeListAction) SetType(v string) { + o.propType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ChangeListAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.changeVariableName.Init(raw) + o.value.Init(raw) + if child, err := codec.DecodeChild(raw, "ValueModel"); err == nil { + o.valueModel.SetFromDecode(child) + } + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ChangeMembersAction +// ──────────────────────────────────────────────────────── + +type ChangeMembersAction struct { + element.Base + errorHandlingType *property.Enum[string] + items *property.PartList[element.Element] + refreshInClient *property.Primitive[bool] + commit *property.Enum[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ChangeMembersAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ChangeMembersAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// ItemsItems returns the value of the items property. +func (o *ChangeMembersAction) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *ChangeMembersAction) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *ChangeMembersAction) RemoveItems(index int) { + o.items.Remove(index) +} + +// RefreshInClient returns the value of the refreshInClient property. +func (o *ChangeMembersAction) RefreshInClient() bool { + return o.refreshInClient.Get() +} + +// SetRefreshInClient sets the value of the refreshInClient property. +func (o *ChangeMembersAction) SetRefreshInClient(v bool) { + o.refreshInClient.Set(v) +} + +// Commit returns the value of the commit property. +func (o *ChangeMembersAction) Commit() string { + return o.commit.Get() +} + +// SetCommit sets the value of the commit property. +func (o *ChangeMembersAction) SetCommit(v string) { + o.commit.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ChangeMembersAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } + o.refreshInClient.Init(raw) + if val, err := raw.LookupErr("Commit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.commit.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ChangeObjectAction +// ──────────────────────────────────────────────────────── + +type ChangeObjectAction struct { + element.Base + errorHandlingType *property.Enum[string] + items *property.PartList[element.Element] + refreshInClient *property.Primitive[bool] + commit *property.Enum[string] + changeVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ChangeObjectAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ChangeObjectAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// ItemsItems returns the value of the items property. +func (o *ChangeObjectAction) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *ChangeObjectAction) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *ChangeObjectAction) RemoveItems(index int) { + o.items.Remove(index) +} + +// RefreshInClient returns the value of the refreshInClient property. +func (o *ChangeObjectAction) RefreshInClient() bool { + return o.refreshInClient.Get() +} + +// SetRefreshInClient sets the value of the refreshInClient property. +func (o *ChangeObjectAction) SetRefreshInClient(v bool) { + o.refreshInClient.Set(v) +} + +// Commit returns the value of the commit property. +func (o *ChangeObjectAction) Commit() string { + return o.commit.Get() +} + +// SetCommit sets the value of the commit property. +func (o *ChangeObjectAction) SetCommit(v string) { + o.commit.Set(v) +} + +// ChangeVariableName returns the value of the changeVariableName property. +func (o *ChangeObjectAction) ChangeVariableName() string { + return o.changeVariableName.Get() +} + +// SetChangeVariableName sets the value of the changeVariableName property. +func (o *ChangeObjectAction) SetChangeVariableName(v string) { + o.changeVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ChangeObjectAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } + o.refreshInClient.Init(raw) + if val, err := raw.LookupErr("Commit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.commit.SetFromDecode(s) } + } + o.changeVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ChangeVariableAction +// ──────────────────────────────────────────────────────── + +type ChangeVariableAction struct { + element.Base + errorHandlingType *property.Enum[string] + changeVariableName *property.Primitive[string] + value *property.Primitive[string] + valueModel *property.Part[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ChangeVariableAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ChangeVariableAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// ChangeVariableName returns the value of the changeVariableName property. +func (o *ChangeVariableAction) ChangeVariableName() string { + return o.changeVariableName.Get() +} + +// SetChangeVariableName sets the value of the changeVariableName property. +func (o *ChangeVariableAction) SetChangeVariableName(v string) { + o.changeVariableName.Set(v) +} + +// Value returns the value of the value property. +func (o *ChangeVariableAction) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *ChangeVariableAction) SetValue(v string) { + o.value.Set(v) +} + +// ValueModel returns the value of the valueModel property. +func (o *ChangeVariableAction) ValueModel() element.Element { + return o.valueModel.Get() +} + +// SetValueModel sets the value of the valueModel property. +func (o *ChangeVariableAction) SetValueModel(v element.Element) { + o.valueModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ChangeVariableAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.changeVariableName.Init(raw) + o.value.Init(raw) + if child, err := codec.DecodeChild(raw, "ValueModel"); err == nil { + o.valueModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ClearFromClientAction +// ──────────────────────────────────────────────────────── + +type ClearFromClientAction struct { + element.Base + errorHandlingType *property.Enum[string] + entity *property.ByNameRef[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ClearFromClientAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ClearFromClientAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *ClearFromClientAction) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *ClearFromClientAction) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ClearFromClientAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// CloseFormAction +// ──────────────────────────────────────────────────────── + +type CloseFormAction struct { + element.Base + errorHandlingType *property.Enum[string] + numberOfPages *property.Primitive[int32] + numberOfPagesToClose *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *CloseFormAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *CloseFormAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// NumberOfPages returns the value of the numberOfPages property. +func (o *CloseFormAction) NumberOfPages() int32 { + return o.numberOfPages.Get() +} + +// SetNumberOfPages sets the value of the numberOfPages property. +func (o *CloseFormAction) SetNumberOfPages(v int32) { + o.numberOfPages.Set(v) +} + +// NumberOfPagesToClose returns the value of the numberOfPagesToClose property. +func (o *CloseFormAction) NumberOfPagesToClose() string { + return o.numberOfPagesToClose.Get() +} + +// SetNumberOfPagesToClose sets the value of the numberOfPagesToClose property. +func (o *CloseFormAction) SetNumberOfPagesToClose(v string) { + o.numberOfPagesToClose.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CloseFormAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.numberOfPages.Init(raw) + o.numberOfPagesToClose.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CodeActionParameterMapping +// ──────────────────────────────────────────────────────── + +type CodeActionParameterMapping struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CodeActionParameterMapping) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CommitAction +// ──────────────────────────────────────────────────────── + +type CommitAction struct { + element.Base + errorHandlingType *property.Enum[string] + withEvents *property.Primitive[bool] + commitVariableName *property.Primitive[string] + refreshInClient *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *CommitAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *CommitAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WithEvents returns the value of the withEvents property. +func (o *CommitAction) WithEvents() bool { + return o.withEvents.Get() +} + +// SetWithEvents sets the value of the withEvents property. +func (o *CommitAction) SetWithEvents(v bool) { + o.withEvents.Set(v) +} + +// CommitVariableName returns the value of the commitVariableName property. +func (o *CommitAction) CommitVariableName() string { + return o.commitVariableName.Get() +} + +// SetCommitVariableName sets the value of the commitVariableName property. +func (o *CommitAction) SetCommitVariableName(v string) { + o.commitVariableName.Set(v) +} + +// RefreshInClient returns the value of the refreshInClient property. +func (o *CommitAction) RefreshInClient() bool { + return o.refreshInClient.Get() +} + +// SetRefreshInClient sets the value of the refreshInClient property. +func (o *CommitAction) SetRefreshInClient(v bool) { + o.refreshInClient.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CommitAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.withEvents.Init(raw) + o.commitVariableName.Init(raw) + o.refreshInClient.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Range +// ──────────────────────────────────────────────────────── + +type Range struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Range) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ConstantRange +// ──────────────────────────────────────────────────────── + +type ConstantRange struct { + element.Base + singleObject *property.Primitive[bool] +} + +// SingleObject returns the value of the singleObject property. +func (o *ConstantRange) SingleObject() bool { + return o.singleObject.Get() +} + +// SetSingleObject sets the value of the singleObject property. +func (o *ConstantRange) SetSingleObject(v bool) { + o.singleObject.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConstantRange) InitFromRaw(raw bson.Raw) { + o.singleObject.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Contains +// ──────────────────────────────────────────────────────── + +type Contains struct { + element.Base + listVariableName *property.Primitive[string] + secondListOrObjectVariableName *property.Primitive[string] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *Contains) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *Contains) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// SecondListOrObjectVariableName returns the value of the secondListOrObjectVariableName property. +func (o *Contains) SecondListOrObjectVariableName() string { + return o.secondListOrObjectVariableName.Get() +} + +// SetSecondListOrObjectVariableName sets the value of the secondListOrObjectVariableName property. +func (o *Contains) SetSecondListOrObjectVariableName(v string) { + o.secondListOrObjectVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Contains) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.secondListOrObjectVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ContinueEvent +// ──────────────────────────────────────────────────────── + +type ContinueEvent struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *ContinueEvent) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *ContinueEvent) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *ContinueEvent) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *ContinueEvent) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ContinueEvent) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ContinueOperation +// ──────────────────────────────────────────────────────── + +type ContinueOperation struct { + element.Base + workflowVariable *property.Primitive[string] +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *ContinueOperation) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *ContinueOperation) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ContinueOperation) InitFromRaw(raw bson.Raw) { + o.workflowVariable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MeterAction +// ──────────────────────────────────────────────────────── + +type MeterAction struct { + element.Base + errorHandlingType *property.Enum[string] + name *property.Primitive[string] + description *property.Primitive[string] + tags *property.PartList[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *MeterAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *MeterAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Name returns the value of the name property. +func (o *MeterAction) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MeterAction) SetName(v string) { + o.name.Set(v) +} + +// Description returns the value of the description property. +func (o *MeterAction) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *MeterAction) SetDescription(v string) { + o.description.Set(v) +} + +// TagsItems returns the value of the tags property. +func (o *MeterAction) TagsItems() []element.Element { + return o.tags.Items() +} + +// AddTags appends a child element to the tags list. +func (o *MeterAction) AddTags(v element.Element) { + o.tags.Append(v) +} + +// RemoveTags removes the element at the given index from the tags list. +func (o *MeterAction) RemoveTags(index int) { + o.tags.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MeterAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.name.Init(raw) + o.description.Init(raw) + if children, err := codec.DecodeChildren(raw, "Tags"); err == nil { + for _, child := range children { + o.tags.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// CounterMeterAction +// ──────────────────────────────────────────────────────── + +type CounterMeterAction struct { + element.Base + errorHandlingType *property.Enum[string] + name *property.Primitive[string] + description *property.Primitive[string] + tags *property.PartList[element.Element] + value *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *CounterMeterAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *CounterMeterAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Name returns the value of the name property. +func (o *CounterMeterAction) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CounterMeterAction) SetName(v string) { + o.name.Set(v) +} + +// Description returns the value of the description property. +func (o *CounterMeterAction) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *CounterMeterAction) SetDescription(v string) { + o.description.Set(v) +} + +// TagsItems returns the value of the tags property. +func (o *CounterMeterAction) TagsItems() []element.Element { + return o.tags.Items() +} + +// AddTags appends a child element to the tags list. +func (o *CounterMeterAction) AddTags(v element.Element) { + o.tags.Append(v) +} + +// RemoveTags removes the element at the given index from the tags list. +func (o *CounterMeterAction) RemoveTags(index int) { + o.tags.Remove(index) +} + +// Value returns the value of the value property. +func (o *CounterMeterAction) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *CounterMeterAction) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CounterMeterAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.name.Init(raw) + o.description.Init(raw) + if children, err := codec.DecodeChildren(raw, "Tags"); err == nil { + for _, child := range children { + o.tags.AppendFromDecode(child) + } + } + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CreateListAction +// ──────────────────────────────────────────────────────── + +type CreateListAction struct { + element.Base + errorHandlingType *property.Enum[string] + entity *property.ByNameRef[element.Element] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *CreateListAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *CreateListAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *CreateListAction) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *CreateListAction) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *CreateListAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *CreateListAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CreateListAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CreateObjectAction +// ──────────────────────────────────────────────────────── + +type CreateObjectAction struct { + element.Base + errorHandlingType *property.Enum[string] + items *property.PartList[element.Element] + refreshInClient *property.Primitive[bool] + commit *property.Enum[string] + entity *property.ByNameRef[element.Element] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *CreateObjectAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *CreateObjectAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// ItemsItems returns the value of the items property. +func (o *CreateObjectAction) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *CreateObjectAction) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *CreateObjectAction) RemoveItems(index int) { + o.items.Remove(index) +} + +// RefreshInClient returns the value of the refreshInClient property. +func (o *CreateObjectAction) RefreshInClient() bool { + return o.refreshInClient.Get() +} + +// SetRefreshInClient sets the value of the refreshInClient property. +func (o *CreateObjectAction) SetRefreshInClient(v bool) { + o.refreshInClient.Set(v) +} + +// Commit returns the value of the commit property. +func (o *CreateObjectAction) Commit() string { + return o.commit.Get() +} + +// SetCommit sets the value of the commit property. +func (o *CreateObjectAction) SetCommit(v string) { + o.commit.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *CreateObjectAction) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *CreateObjectAction) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *CreateObjectAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *CreateObjectAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CreateObjectAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } + o.refreshInClient.Init(raw) + if val, err := raw.LookupErr("Commit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.commit.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CreateVariableAction +// ──────────────────────────────────────────────────────── + +type CreateVariableAction struct { + element.Base + errorHandlingType *property.Enum[string] + variableName *property.Primitive[string] + variableDataType *property.Primitive[string] + variableType *property.Part[element.Element] + initialValue *property.Primitive[string] + initialValueModel *property.Part[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *CreateVariableAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *CreateVariableAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// VariableName returns the value of the variableName property. +func (o *CreateVariableAction) VariableName() string { + return o.variableName.Get() +} + +// SetVariableName sets the value of the variableName property. +func (o *CreateVariableAction) SetVariableName(v string) { + o.variableName.Set(v) +} + +// VariableDataType returns the value of the variableDataType property. +func (o *CreateVariableAction) VariableDataType() string { + return o.variableDataType.Get() +} + +// SetVariableDataType sets the value of the variableDataType property. +func (o *CreateVariableAction) SetVariableDataType(v string) { + o.variableDataType.Set(v) +} + +// VariableType returns the value of the variableType property. +func (o *CreateVariableAction) VariableType() element.Element { + return o.variableType.Get() +} + +// SetVariableType sets the value of the variableType property. +func (o *CreateVariableAction) SetVariableType(v element.Element) { + o.variableType.Set(v) +} + +// InitialValue returns the value of the initialValue property. +func (o *CreateVariableAction) InitialValue() string { + return o.initialValue.Get() +} + +// SetInitialValue sets the value of the initialValue property. +func (o *CreateVariableAction) SetInitialValue(v string) { + o.initialValue.Set(v) +} + +// InitialValueModel returns the value of the initialValueModel property. +func (o *CreateVariableAction) InitialValueModel() element.Element { + return o.initialValueModel.Get() +} + +// SetInitialValueModel sets the value of the initialValueModel property. +func (o *CreateVariableAction) SetInitialValueModel(v element.Element) { + o.initialValueModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CreateVariableAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.variableName.Init(raw) + o.variableDataType.Init(raw) + if child, err := codec.DecodeChild(raw, "VariableType"); err == nil { + o.variableType.SetFromDecode(child) + } + o.initialValue.Init(raw) + if child, err := codec.DecodeChild(raw, "InitialValueModel"); err == nil { + o.initialValueModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// CustomBlobDocumentCodeActionParameterValue +// ──────────────────────────────────────────────────────── + +type CustomBlobDocumentCodeActionParameterValue struct { + element.Base + customDocument *property.ByNameRef[element.Element] +} + +// CustomDocumentQualifiedName returns the value of the customDocument property. +func (o *CustomBlobDocumentCodeActionParameterValue) CustomDocumentQualifiedName() string { + return o.customDocument.QualifiedName() +} + +// SetCustomDocumentQualifiedName sets the value of the customDocument property. +func (o *CustomBlobDocumentCodeActionParameterValue) SetCustomDocumentQualifiedName(v string) { + o.customDocument.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomBlobDocumentCodeActionParameterValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("CustomDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { o.customDocument.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// CustomRange +// ──────────────────────────────────────────────────────── + +type CustomRange struct { + element.Base + limitExpression *property.Primitive[string] + offsetExpression *property.Primitive[string] + limitExpressionModel *property.Part[element.Element] + offsetExpressionModel *property.Part[element.Element] +} + +// LimitExpression returns the value of the limitExpression property. +func (o *CustomRange) LimitExpression() string { + return o.limitExpression.Get() +} + +// SetLimitExpression sets the value of the limitExpression property. +func (o *CustomRange) SetLimitExpression(v string) { + o.limitExpression.Set(v) +} + +// OffsetExpression returns the value of the offsetExpression property. +func (o *CustomRange) OffsetExpression() string { + return o.offsetExpression.Get() +} + +// SetOffsetExpression sets the value of the offsetExpression property. +func (o *CustomRange) SetOffsetExpression(v string) { + o.offsetExpression.Set(v) +} + +// LimitExpressionModel returns the value of the limitExpressionModel property. +func (o *CustomRange) LimitExpressionModel() element.Element { + return o.limitExpressionModel.Get() +} + +// SetLimitExpressionModel sets the value of the limitExpressionModel property. +func (o *CustomRange) SetLimitExpressionModel(v element.Element) { + o.limitExpressionModel.Set(v) +} + +// OffsetExpressionModel returns the value of the offsetExpressionModel property. +func (o *CustomRange) OffsetExpressionModel() element.Element { + return o.offsetExpressionModel.Get() +} + +// SetOffsetExpressionModel sets the value of the offsetExpressionModel property. +func (o *CustomRange) SetOffsetExpressionModel(v element.Element) { + o.offsetExpressionModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomRange) InitFromRaw(raw bson.Raw) { + o.limitExpression.Init(raw) + o.offsetExpression.Init(raw) + if child, err := codec.DecodeChild(raw, "LimitExpressionModel"); err == nil { + o.limitExpressionModel.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OffsetExpressionModel"); err == nil { + o.offsetExpressionModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// CustomRequestHandling +// ──────────────────────────────────────────────────────── + +type CustomRequestHandling struct { + element.Base + template *property.Part[element.Element] +} + +// Template returns the value of the template property. +func (o *CustomRequestHandling) Template() element.Element { + return o.template.Get() +} + +// SetTemplate sets the value of the template property. +func (o *CustomRequestHandling) SetTemplate(v element.Element) { + o.template.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomRequestHandling) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Template"); err == nil { + o.template.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DatabaseRetrieveSource +// ──────────────────────────────────────────────────────── + +type DatabaseRetrieveSource struct { + element.Base + entity *property.ByNameRef[element.Element] + propRange *property.Part[element.Element] + xPathConstraint *property.Primitive[string] + sortItemList *property.Part[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *DatabaseRetrieveSource) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *DatabaseRetrieveSource) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// Range returns the value of the range property. +func (o *DatabaseRetrieveSource) Range() element.Element { + return o.propRange.Get() +} + +// SetRange sets the value of the range property. +func (o *DatabaseRetrieveSource) SetRange(v element.Element) { + o.propRange.Set(v) +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *DatabaseRetrieveSource) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *DatabaseRetrieveSource) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// SortItemList returns the value of the sortItemList property. +func (o *DatabaseRetrieveSource) SortItemList() element.Element { + return o.sortItemList.Get() +} + +// SetSortItemList sets the value of the sortItemList property. +func (o *DatabaseRetrieveSource) SetSortItemList(v element.Element) { + o.sortItemList.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DatabaseRetrieveSource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Range"); err == nil { + o.propRange.SetFromDecode(child) + } + o.xPathConstraint.Init(raw) + if child, err := codec.DecodeChild(raw, "SortItemList"); err == nil { + o.sortItemList.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DeleteAction +// ──────────────────────────────────────────────────────── + +type DeleteAction struct { + element.Base + errorHandlingType *property.Enum[string] + deleteVariableName *property.Primitive[string] + refreshInClient *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *DeleteAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *DeleteAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// DeleteVariableName returns the value of the deleteVariableName property. +func (o *DeleteAction) DeleteVariableName() string { + return o.deleteVariableName.Get() +} + +// SetDeleteVariableName sets the value of the deleteVariableName property. +func (o *DeleteAction) SetDeleteVariableName(v string) { + o.deleteVariableName.Set(v) +} + +// RefreshInClient returns the value of the refreshInClient property. +func (o *DeleteAction) RefreshInClient() bool { + return o.refreshInClient.Get() +} + +// SetRefreshInClient sets the value of the refreshInClient property. +func (o *DeleteAction) SetRefreshInClient(v bool) { + o.refreshInClient.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DeleteAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.deleteVariableName.Init(raw) + o.refreshInClient.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DeleteExternalObject +// ──────────────────────────────────────────────────────── + +type DeleteExternalObject struct { + element.Base + errorHandlingType *property.Enum[string] + deleteVariableName *property.Primitive[string] + refreshInClient *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *DeleteExternalObject) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *DeleteExternalObject) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// DeleteVariableName returns the value of the deleteVariableName property. +func (o *DeleteExternalObject) DeleteVariableName() string { + return o.deleteVariableName.Get() +} + +// SetDeleteVariableName sets the value of the deleteVariableName property. +func (o *DeleteExternalObject) SetDeleteVariableName(v string) { + o.deleteVariableName.Set(v) +} + +// RefreshInClient returns the value of the refreshInClient property. +func (o *DeleteExternalObject) RefreshInClient() bool { + return o.refreshInClient.Get() +} + +// SetRefreshInClient sets the value of the refreshInClient property. +func (o *DeleteExternalObject) SetRefreshInClient(v bool) { + o.refreshInClient.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DeleteExternalObject) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.deleteVariableName.Init(raw) + o.refreshInClient.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DocumentTemplateParameterMapping +// ──────────────────────────────────────────────────────── + +type DocumentTemplateParameterMapping struct { + element.Base + widgetName *property.Primitive[string] + argument *property.Primitive[string] + argumentModel *property.Part[element.Element] +} + +// WidgetName returns the value of the widgetName property. +func (o *DocumentTemplateParameterMapping) WidgetName() string { + return o.widgetName.Get() +} + +// SetWidgetName sets the value of the widgetName property. +func (o *DocumentTemplateParameterMapping) SetWidgetName(v string) { + o.widgetName.Set(v) +} + +// Argument returns the value of the argument property. +func (o *DocumentTemplateParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *DocumentTemplateParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// ArgumentModel returns the value of the argumentModel property. +func (o *DocumentTemplateParameterMapping) ArgumentModel() element.Element { + return o.argumentModel.Get() +} + +// SetArgumentModel sets the value of the argumentModel property. +func (o *DocumentTemplateParameterMapping) SetArgumentModel(v element.Element) { + o.argumentModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DocumentTemplateParameterMapping) InitFromRaw(raw bson.Raw) { + o.widgetName.Init(raw) + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "ArgumentModel"); err == nil { + o.argumentModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DownloadFileAction +// ──────────────────────────────────────────────────────── + +type DownloadFileAction struct { + element.Base + errorHandlingType *property.Enum[string] + fileDocumentVariableName *property.Primitive[string] + showFileInBrowser *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *DownloadFileAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *DownloadFileAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// FileDocumentVariableName returns the value of the fileDocumentVariableName property. +func (o *DownloadFileAction) FileDocumentVariableName() string { + return o.fileDocumentVariableName.Get() +} + +// SetFileDocumentVariableName sets the value of the fileDocumentVariableName property. +func (o *DownloadFileAction) SetFileDocumentVariableName(v string) { + o.fileDocumentVariableName.Set(v) +} + +// ShowFileInBrowser returns the value of the showFileInBrowser property. +func (o *DownloadFileAction) ShowFileInBrowser() bool { + return o.showFileInBrowser.Get() +} + +// SetShowFileInBrowser sets the value of the showFileInBrowser property. +func (o *DownloadFileAction) SetShowFileInBrowser(v bool) { + o.showFileInBrowser.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DownloadFileAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.fileDocumentVariableName.Init(raw) + o.showFileInBrowser.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EmailConnectionConfig +// ──────────────────────────────────────────────────────── + +type EmailConnectionConfig struct { + element.Base + emailId *property.Primitive[string] + protocol *property.Enum[string] + host *property.Primitive[string] + port *property.Primitive[string] + securityType *property.Enum[string] + checkServerIdentity *property.Primitive[bool] + connectionTimeout *property.Primitive[int32] +} + +// EmailId returns the value of the emailId property. +func (o *EmailConnectionConfig) EmailId() string { + return o.emailId.Get() +} + +// SetEmailId sets the value of the emailId property. +func (o *EmailConnectionConfig) SetEmailId(v string) { + o.emailId.Set(v) +} + +// Protocol returns the value of the protocol property. +func (o *EmailConnectionConfig) Protocol() string { + return o.protocol.Get() +} + +// SetProtocol sets the value of the protocol property. +func (o *EmailConnectionConfig) SetProtocol(v string) { + o.protocol.Set(v) +} + +// Host returns the value of the host property. +func (o *EmailConnectionConfig) Host() string { + return o.host.Get() +} + +// SetHost sets the value of the host property. +func (o *EmailConnectionConfig) SetHost(v string) { + o.host.Set(v) +} + +// Port returns the value of the port property. +func (o *EmailConnectionConfig) Port() string { + return o.port.Get() +} + +// SetPort sets the value of the port property. +func (o *EmailConnectionConfig) SetPort(v string) { + o.port.Set(v) +} + +// SecurityType returns the value of the securityType property. +func (o *EmailConnectionConfig) SecurityType() string { + return o.securityType.Get() +} + +// SetSecurityType sets the value of the securityType property. +func (o *EmailConnectionConfig) SetSecurityType(v string) { + o.securityType.Set(v) +} + +// CheckServerIdentity returns the value of the checkServerIdentity property. +func (o *EmailConnectionConfig) CheckServerIdentity() bool { + return o.checkServerIdentity.Get() +} + +// SetCheckServerIdentity sets the value of the checkServerIdentity property. +func (o *EmailConnectionConfig) SetCheckServerIdentity(v bool) { + o.checkServerIdentity.Set(v) +} + +// ConnectionTimeout returns the value of the connectionTimeout property. +func (o *EmailConnectionConfig) ConnectionTimeout() int32 { + return o.connectionTimeout.Get() +} + +// SetConnectionTimeout sets the value of the connectionTimeout property. +func (o *EmailConnectionConfig) SetConnectionTimeout(v int32) { + o.connectionTimeout.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EmailConnectionConfig) InitFromRaw(raw bson.Raw) { + o.emailId.Init(raw) + if val, err := raw.LookupErr("Protocol"); err == nil { + if s, ok := val.StringValueOK(); ok { o.protocol.SetFromDecode(s) } + } + o.host.Init(raw) + o.port.Init(raw) + if val, err := raw.LookupErr("SecurityType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.securityType.SetFromDecode(s) } + } + o.checkServerIdentity.Init(raw) + o.connectionTimeout.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EmailMessage +// ──────────────────────────────────────────────────────── + +type EmailMessage struct { + element.Base + to *property.Primitive[string] + cc *property.Primitive[string] + bcc *property.Primitive[string] + subject *property.Primitive[string] + messageBodyPlainText *property.Primitive[string] + messageBodyHtml *property.Primitive[string] + attachments *property.ByNameRefList[element.Element] + attachment *property.Primitive[string] +} + +// To returns the value of the to property. +func (o *EmailMessage) To() string { + return o.to.Get() +} + +// SetTo sets the value of the to property. +func (o *EmailMessage) SetTo(v string) { + o.to.Set(v) +} + +// Cc returns the value of the cc property. +func (o *EmailMessage) Cc() string { + return o.cc.Get() +} + +// SetCc sets the value of the cc property. +func (o *EmailMessage) SetCc(v string) { + o.cc.Set(v) +} + +// Bcc returns the value of the bcc property. +func (o *EmailMessage) Bcc() string { + return o.bcc.Get() +} + +// SetBcc sets the value of the bcc property. +func (o *EmailMessage) SetBcc(v string) { + o.bcc.Set(v) +} + +// Subject returns the value of the subject property. +func (o *EmailMessage) Subject() string { + return o.subject.Get() +} + +// SetSubject sets the value of the subject property. +func (o *EmailMessage) SetSubject(v string) { + o.subject.Set(v) +} + +// MessageBodyPlainText returns the value of the messageBodyPlainText property. +func (o *EmailMessage) MessageBodyPlainText() string { + return o.messageBodyPlainText.Get() +} + +// SetMessageBodyPlainText sets the value of the messageBodyPlainText property. +func (o *EmailMessage) SetMessageBodyPlainText(v string) { + o.messageBodyPlainText.Set(v) +} + +// MessageBodyHtml returns the value of the messageBodyHtml property. +func (o *EmailMessage) MessageBodyHtml() string { + return o.messageBodyHtml.Get() +} + +// SetMessageBodyHtml sets the value of the messageBodyHtml property. +func (o *EmailMessage) SetMessageBodyHtml(v string) { + o.messageBodyHtml.Set(v) +} + +// AttachmentsQualifiedNames returns the value of the attachments property. +func (o *EmailMessage) AttachmentsQualifiedNames() []string { + return o.attachments.QualifiedNames() +} + +// SetAttachmentsQualifiedNames sets the value of the attachments property. +func (o *EmailMessage) SetAttachmentsQualifiedNames(v []string) { + o.attachments.SetQualifiedNames(v) +} + +// AddAttachments appends a child element to the attachments list. +func (o *EmailMessage) AddAttachments(v string) { + o.attachments.Append(v) +} + +// Attachment returns the value of the attachment property. +func (o *EmailMessage) Attachment() string { + return o.attachment.Get() +} + +// SetAttachment sets the value of the attachment property. +func (o *EmailMessage) SetAttachment(v string) { + o.attachment.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EmailMessage) InitFromRaw(raw bson.Raw) { + o.to.Init(raw) + o.cc.Init(raw) + o.bcc.Init(raw) + o.subject.Init(raw) + o.messageBodyPlainText.Init(raw) + o.messageBodyHtml.Init(raw) + if val, err := raw.LookupErr("Attachments"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.attachments.SetFromDecode(qnames) + } + } + o.attachment.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EndEvent +// ──────────────────────────────────────────────────────── + +type EndEvent struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + returnValue *property.Primitive[string] + returnValueModel *property.Part[element.Element] + documentation *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *EndEvent) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *EndEvent) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *EndEvent) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *EndEvent) SetSize(v string) { + o.size.Set(v) +} + +// ReturnValue returns the value of the returnValue property. +func (o *EndEvent) ReturnValue() string { + return o.returnValue.Get() +} + +// SetReturnValue sets the value of the returnValue property. +func (o *EndEvent) SetReturnValue(v string) { + o.returnValue.Set(v) +} + +// ReturnValueModel returns the value of the returnValueModel property. +func (o *EndEvent) ReturnValueModel() element.Element { + return o.returnValueModel.Get() +} + +// SetReturnValueModel sets the value of the returnValueModel property. +func (o *EndEvent) SetReturnValueModel(v element.Element) { + o.returnValueModel.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *EndEvent) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *EndEvent) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EndEvent) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + o.returnValue.Init(raw) + if child, err := codec.DecodeChild(raw, "ReturnValueModel"); err == nil { + o.returnValueModel.SetFromDecode(child) + } + o.documentation.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EntityTypeCodeActionParameterValue +// ──────────────────────────────────────────────────────── + +type EntityTypeCodeActionParameterValue struct { + element.Base + entity *property.ByNameRef[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *EntityTypeCodeActionParameterValue) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *EntityTypeCodeActionParameterValue) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityTypeCodeActionParameterValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// EntityTypeJavaActionParameterValue +// ──────────────────────────────────────────────────────── + +type EntityTypeJavaActionParameterValue struct { + element.Base + entity *property.ByNameRef[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *EntityTypeJavaActionParameterValue) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *EntityTypeJavaActionParameterValue) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityTypeJavaActionParameterValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// EnumerationCase +// ──────────────────────────────────────────────────────── + +type EnumerationCase struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *EnumerationCase) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *EnumerationCase) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EnumerationCase) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ErrorEvent +// ──────────────────────────────────────────────────────── + +type ErrorEvent struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *ErrorEvent) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *ErrorEvent) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *ErrorEvent) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *ErrorEvent) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ErrorEvent) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ExclusiveMerge +// ──────────────────────────────────────────────────────── + +type ExclusiveMerge struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *ExclusiveMerge) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *ExclusiveMerge) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *ExclusiveMerge) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *ExclusiveMerge) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExclusiveMerge) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ExclusiveSplit +// ──────────────────────────────────────────────────────── + +type ExclusiveSplit struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + splitCondition *property.Part[element.Element] + caption *property.Primitive[string] + errorHandlingType *property.Enum[string] + documentation *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *ExclusiveSplit) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *ExclusiveSplit) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *ExclusiveSplit) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *ExclusiveSplit) SetSize(v string) { + o.size.Set(v) +} + +// SplitCondition returns the value of the splitCondition property. +func (o *ExclusiveSplit) SplitCondition() element.Element { + return o.splitCondition.Get() +} + +// SetSplitCondition sets the value of the splitCondition property. +func (o *ExclusiveSplit) SetSplitCondition(v element.Element) { + o.splitCondition.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ExclusiveSplit) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ExclusiveSplit) SetCaption(v string) { + o.caption.Set(v) +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ExclusiveSplit) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ExclusiveSplit) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ExclusiveSplit) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ExclusiveSplit) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExclusiveSplit) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if child, err := codec.DecodeChild(raw, "SplitCondition"); err == nil { + o.splitCondition.SetFromDecode(child) + } + o.caption.Init(raw) + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.documentation.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ExportMappingJavaActionParameterValue +// ──────────────────────────────────────────────────────── + +type ExportMappingJavaActionParameterValue struct { + element.Base + exportMapping *property.ByNameRef[element.Element] +} + +// ExportMappingQualifiedName returns the value of the exportMapping property. +func (o *ExportMappingJavaActionParameterValue) ExportMappingQualifiedName() string { + return o.exportMapping.QualifiedName() +} + +// SetExportMappingQualifiedName sets the value of the exportMapping property. +func (o *ExportMappingJavaActionParameterValue) SetExportMappingQualifiedName(v string) { + o.exportMapping.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExportMappingJavaActionParameterValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ExportMapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportMapping.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ExportMappingParameterValue +// ──────────────────────────────────────────────────────── + +type ExportMappingParameterValue struct { + element.Base + exportMapping *property.ByNameRef[element.Element] +} + +// ExportMappingQualifiedName returns the value of the exportMapping property. +func (o *ExportMappingParameterValue) ExportMappingQualifiedName() string { + return o.exportMapping.QualifiedName() +} + +// SetExportMappingQualifiedName sets the value of the exportMapping property. +func (o *ExportMappingParameterValue) SetExportMappingQualifiedName(v string) { + o.exportMapping.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExportMappingParameterValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ExportMapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportMapping.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ExportXmlAction +// ──────────────────────────────────────────────────────── + +type ExportXmlAction struct { + element.Base + errorHandlingType *property.Enum[string] + mapping *property.ByNameRef[element.Element] + mappingArgumentVariableName *property.Primitive[string] + resultHandling *property.Part[element.Element] + outputMethod *property.Part[element.Element] + isValidationRequired *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ExportXmlAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ExportXmlAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// MappingQualifiedName returns the value of the mapping property. +func (o *ExportXmlAction) MappingQualifiedName() string { + return o.mapping.QualifiedName() +} + +// SetMappingQualifiedName sets the value of the mapping property. +func (o *ExportXmlAction) SetMappingQualifiedName(v string) { + o.mapping.SetQualifiedName(v) +} + +// MappingArgumentVariableName returns the value of the mappingArgumentVariableName property. +func (o *ExportXmlAction) MappingArgumentVariableName() string { + return o.mappingArgumentVariableName.Get() +} + +// SetMappingArgumentVariableName sets the value of the mappingArgumentVariableName property. +func (o *ExportXmlAction) SetMappingArgumentVariableName(v string) { + o.mappingArgumentVariableName.Set(v) +} + +// ResultHandling returns the value of the resultHandling property. +func (o *ExportXmlAction) ResultHandling() element.Element { + return o.resultHandling.Get() +} + +// SetResultHandling sets the value of the resultHandling property. +func (o *ExportXmlAction) SetResultHandling(v element.Element) { + o.resultHandling.Set(v) +} + +// OutputMethod returns the value of the outputMethod property. +func (o *ExportXmlAction) OutputMethod() element.Element { + return o.outputMethod.Get() +} + +// SetOutputMethod sets the value of the outputMethod property. +func (o *ExportXmlAction) SetOutputMethod(v element.Element) { + o.outputMethod.Set(v) +} + +// IsValidationRequired returns the value of the isValidationRequired property. +func (o *ExportXmlAction) IsValidationRequired() bool { + return o.isValidationRequired.Get() +} + +// SetIsValidationRequired sets the value of the isValidationRequired property. +func (o *ExportXmlAction) SetIsValidationRequired(v bool) { + o.isValidationRequired.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExportXmlAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Mapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.mapping.SetFromDecode(s) } + } + o.mappingArgumentVariableName.Init(raw) + if child, err := codec.DecodeChild(raw, "ResultHandling"); err == nil { + o.resultHandling.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OutputMethod"); err == nil { + o.outputMethod.SetFromDecode(child) + } + o.isValidationRequired.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ExpressionListOperation +// ──────────────────────────────────────────────────────── + +type ExpressionListOperation struct { + element.Base + listVariableName *property.Primitive[string] + expression *property.Primitive[string] + expressionModel *property.Part[element.Element] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *ExpressionListOperation) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *ExpressionListOperation) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// Expression returns the value of the expression property. +func (o *ExpressionListOperation) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *ExpressionListOperation) SetExpression(v string) { + o.expression.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *ExpressionListOperation) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *ExpressionListOperation) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExpressionListOperation) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// SplitCondition +// ──────────────────────────────────────────────────────── + +type SplitCondition struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SplitCondition) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ExpressionSplitCondition +// ──────────────────────────────────────────────────────── + +type ExpressionSplitCondition struct { + element.Base + expression *property.Primitive[string] + expressionModel *property.Part[element.Element] +} + +// Expression returns the value of the expression property. +func (o *ExpressionSplitCondition) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *ExpressionSplitCondition) SetExpression(v string) { + o.expression.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *ExpressionSplitCondition) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *ExpressionSplitCondition) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExpressionSplitCondition) InitFromRaw(raw bson.Raw) { + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ExternalActionParameterMapping +// ──────────────────────────────────────────────────────── + +type ExternalActionParameterMapping struct { + element.Base + parameterName *property.Primitive[string] + parameterType *property.Part[element.Element] + canBeEmpty *property.Primitive[bool] + argument *property.Primitive[string] + includedAssociations *property.PartList[element.Element] + additionalAttributes *property.PartList[element.Element] +} + +// ParameterName returns the value of the parameterName property. +func (o *ExternalActionParameterMapping) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *ExternalActionParameterMapping) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *ExternalActionParameterMapping) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *ExternalActionParameterMapping) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// CanBeEmpty returns the value of the canBeEmpty property. +func (o *ExternalActionParameterMapping) CanBeEmpty() bool { + return o.canBeEmpty.Get() +} + +// SetCanBeEmpty sets the value of the canBeEmpty property. +func (o *ExternalActionParameterMapping) SetCanBeEmpty(v bool) { + o.canBeEmpty.Set(v) +} + +// Argument returns the value of the argument property. +func (o *ExternalActionParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *ExternalActionParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// IncludedAssociationsItems returns the value of the includedAssociations property. +func (o *ExternalActionParameterMapping) IncludedAssociationsItems() []element.Element { + return o.includedAssociations.Items() +} + +// AddIncludedAssociations appends a child element to the includedAssociations list. +func (o *ExternalActionParameterMapping) AddIncludedAssociations(v element.Element) { + o.includedAssociations.Append(v) +} + +// RemoveIncludedAssociations removes the element at the given index from the includedAssociations list. +func (o *ExternalActionParameterMapping) RemoveIncludedAssociations(index int) { + o.includedAssociations.Remove(index) +} + +// AdditionalAttributesItems returns the value of the additionalAttributes property. +func (o *ExternalActionParameterMapping) AdditionalAttributesItems() []element.Element { + return o.additionalAttributes.Items() +} + +// AddAdditionalAttributes appends a child element to the additionalAttributes list. +func (o *ExternalActionParameterMapping) AddAdditionalAttributes(v element.Element) { + o.additionalAttributes.Append(v) +} + +// RemoveAdditionalAttributes removes the element at the given index from the additionalAttributes list. +func (o *ExternalActionParameterMapping) RemoveAdditionalAttributes(index int) { + o.additionalAttributes.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExternalActionParameterMapping) InitFromRaw(raw bson.Raw) { + o.parameterName.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } + o.canBeEmpty.Init(raw) + o.argument.Init(raw) + if children, err := codec.DecodeChildren(raw, "IncludedAssociations"); err == nil { + for _, child := range children { + o.includedAssociations.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "AdditionalAttributes"); err == nil { + for _, child := range children { + o.additionalAttributes.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// OutputMethod +// ──────────────────────────────────────────────────────── + +type OutputMethod struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OutputMethod) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// FileDocumentExport +// ──────────────────────────────────────────────────────── + +type FileDocumentExport struct { + element.Base + targetDocumentVariableName *property.Primitive[string] +} + +// TargetDocumentVariableName returns the value of the targetDocumentVariableName property. +func (o *FileDocumentExport) TargetDocumentVariableName() string { + return o.targetDocumentVariableName.Get() +} + +// SetTargetDocumentVariableName sets the value of the targetDocumentVariableName property. +func (o *FileDocumentExport) SetTargetDocumentVariableName(v string) { + o.targetDocumentVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FileDocumentExport) InitFromRaw(raw bson.Raw) { + o.targetDocumentVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// InspectAttribute +// ──────────────────────────────────────────────────────── + +type InspectAttribute struct { + element.Base + listVariableName *property.Primitive[string] + expression *property.Primitive[string] + expressionModel *property.Part[element.Element] + attribute *property.ByNameRef[element.Element] + association *property.ByNameRef[element.Element] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *InspectAttribute) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *InspectAttribute) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// Expression returns the value of the expression property. +func (o *InspectAttribute) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *InspectAttribute) SetExpression(v string) { + o.expression.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *InspectAttribute) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *InspectAttribute) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *InspectAttribute) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *InspectAttribute) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *InspectAttribute) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *InspectAttribute) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *InspectAttribute) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { o.association.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// Filter +// ──────────────────────────────────────────────────────── + +type Filter struct { + element.Base + listVariableName *property.Primitive[string] + expression *property.Primitive[string] + expressionModel *property.Part[element.Element] + attribute *property.ByNameRef[element.Element] + association *property.ByNameRef[element.Element] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *Filter) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *Filter) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// Expression returns the value of the expression property. +func (o *Filter) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *Filter) SetExpression(v string) { + o.expression.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *Filter) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *Filter) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *Filter) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *Filter) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *Filter) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *Filter) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Filter) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { o.association.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// FilterByExpression +// ──────────────────────────────────────────────────────── + +type FilterByExpression struct { + element.Base + listVariableName *property.Primitive[string] + expression *property.Primitive[string] + expressionModel *property.Part[element.Element] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *FilterByExpression) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *FilterByExpression) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// Expression returns the value of the expression property. +func (o *FilterByExpression) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *FilterByExpression) SetExpression(v string) { + o.expression.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *FilterByExpression) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *FilterByExpression) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FilterByExpression) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Find +// ──────────────────────────────────────────────────────── + +type Find struct { + element.Base + listVariableName *property.Primitive[string] + expression *property.Primitive[string] + expressionModel *property.Part[element.Element] + attribute *property.ByNameRef[element.Element] + association *property.ByNameRef[element.Element] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *Find) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *Find) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// Expression returns the value of the expression property. +func (o *Find) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *Find) SetExpression(v string) { + o.expression.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *Find) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *Find) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *Find) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *Find) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *Find) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *Find) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Find) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { o.association.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// FindByExpression +// ──────────────────────────────────────────────────────── + +type FindByExpression struct { + element.Base + listVariableName *property.Primitive[string] + expression *property.Primitive[string] + expressionModel *property.Part[element.Element] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *FindByExpression) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *FindByExpression) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// Expression returns the value of the expression property. +func (o *FindByExpression) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *FindByExpression) SetExpression(v string) { + o.expression.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *FindByExpression) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *FindByExpression) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FindByExpression) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// FormDataPart +// ──────────────────────────────────────────────────────── + +type FormDataPart struct { + element.Base + key *property.Primitive[string] + value *property.Primitive[string] + valueModel *property.Part[element.Element] + headerEntries *property.PartList[element.Element] +} + +// Key returns the value of the key property. +func (o *FormDataPart) Key() string { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *FormDataPart) SetKey(v string) { + o.key.Set(v) +} + +// Value returns the value of the value property. +func (o *FormDataPart) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *FormDataPart) SetValue(v string) { + o.value.Set(v) +} + +// ValueModel returns the value of the valueModel property. +func (o *FormDataPart) ValueModel() element.Element { + return o.valueModel.Get() +} + +// SetValueModel sets the value of the valueModel property. +func (o *FormDataPart) SetValueModel(v element.Element) { + o.valueModel.Set(v) +} + +// HeaderEntriesItems returns the value of the headerEntries property. +func (o *FormDataPart) HeaderEntriesItems() []element.Element { + return o.headerEntries.Items() +} + +// AddHeaderEntries appends a child element to the headerEntries list. +func (o *FormDataPart) AddHeaderEntries(v element.Element) { + o.headerEntries.Append(v) +} + +// RemoveHeaderEntries removes the element at the given index from the headerEntries list. +func (o *FormDataPart) RemoveHeaderEntries(index int) { + o.headerEntries.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FormDataPart) InitFromRaw(raw bson.Raw) { + o.key.Init(raw) + o.value.Init(raw) + if child, err := codec.DecodeChild(raw, "ValueModel"); err == nil { + o.valueModel.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "HeaderEntries"); err == nil { + for _, child := range children { + o.headerEntries.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// FormDataRequestHandling +// ──────────────────────────────────────────────────────── + +type FormDataRequestHandling struct { + element.Base + parts *property.PartList[element.Element] +} + +// PartsItems returns the value of the parts property. +func (o *FormDataRequestHandling) PartsItems() []element.Element { + return o.parts.Items() +} + +// AddParts appends a child element to the parts list. +func (o *FormDataRequestHandling) AddParts(v element.Element) { + o.parts.Append(v) +} + +// RemoveParts removes the element at the given index from the parts list. +func (o *FormDataRequestHandling) RemoveParts(index int) { + o.parts.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FormDataRequestHandling) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Parts"); err == nil { + for _, child := range children { + o.parts.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// GaugeMeterAction +// ──────────────────────────────────────────────────────── + +type GaugeMeterAction struct { + element.Base + errorHandlingType *property.Enum[string] + name *property.Primitive[string] + description *property.Primitive[string] + tags *property.PartList[element.Element] + value *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *GaugeMeterAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *GaugeMeterAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Name returns the value of the name property. +func (o *GaugeMeterAction) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GaugeMeterAction) SetName(v string) { + o.name.Set(v) +} + +// Description returns the value of the description property. +func (o *GaugeMeterAction) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *GaugeMeterAction) SetDescription(v string) { + o.description.Set(v) +} + +// TagsItems returns the value of the tags property. +func (o *GaugeMeterAction) TagsItems() []element.Element { + return o.tags.Items() +} + +// AddTags appends a child element to the tags list. +func (o *GaugeMeterAction) AddTags(v element.Element) { + o.tags.Append(v) +} + +// RemoveTags removes the element at the given index from the tags list. +func (o *GaugeMeterAction) RemoveTags(index int) { + o.tags.Remove(index) +} + +// Value returns the value of the value property. +func (o *GaugeMeterAction) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *GaugeMeterAction) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GaugeMeterAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.name.Init(raw) + o.description.Init(raw) + if children, err := codec.DecodeChildren(raw, "Tags"); err == nil { + for _, child := range children { + o.tags.AppendFromDecode(child) + } + } + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// GenerateDocumentAction +// ──────────────────────────────────────────────────────── + +type GenerateDocumentAction struct { + element.Base + errorHandlingType *property.Enum[string] + fileVariableName *property.Primitive[string] + languageVariableName *property.Primitive[string] + documentType *property.Enum[string] + languageSetting *property.Enum[string] + documentTemplate *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] + overrideTopMargin *property.Primitive[bool] + overrideBottomMargin *property.Primitive[bool] + overrideLeftMargin *property.Primitive[bool] + overrideRightMargin *property.Primitive[bool] + marginLeftInInch *property.Primitive[string] + marginLeftInInchModel *property.Part[element.Element] + marginRightInInch *property.Primitive[string] + marginRightInInchModel *property.Part[element.Element] + marginTopInInch *property.Primitive[string] + marginTopInInchModel *property.Part[element.Element] + marginBottomInInch *property.Primitive[string] + marginBottomInInchModel *property.Part[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *GenerateDocumentAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *GenerateDocumentAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// FileVariableName returns the value of the fileVariableName property. +func (o *GenerateDocumentAction) FileVariableName() string { + return o.fileVariableName.Get() +} + +// SetFileVariableName sets the value of the fileVariableName property. +func (o *GenerateDocumentAction) SetFileVariableName(v string) { + o.fileVariableName.Set(v) +} + +// LanguageVariableName returns the value of the languageVariableName property. +func (o *GenerateDocumentAction) LanguageVariableName() string { + return o.languageVariableName.Get() +} + +// SetLanguageVariableName sets the value of the languageVariableName property. +func (o *GenerateDocumentAction) SetLanguageVariableName(v string) { + o.languageVariableName.Set(v) +} + +// DocumentType returns the value of the documentType property. +func (o *GenerateDocumentAction) DocumentType() string { + return o.documentType.Get() +} + +// SetDocumentType sets the value of the documentType property. +func (o *GenerateDocumentAction) SetDocumentType(v string) { + o.documentType.Set(v) +} + +// LanguageSetting returns the value of the languageSetting property. +func (o *GenerateDocumentAction) LanguageSetting() string { + return o.languageSetting.Get() +} + +// SetLanguageSetting sets the value of the languageSetting property. +func (o *GenerateDocumentAction) SetLanguageSetting(v string) { + o.languageSetting.Set(v) +} + +// DocumentTemplateQualifiedName returns the value of the documentTemplate property. +func (o *GenerateDocumentAction) DocumentTemplateQualifiedName() string { + return o.documentTemplate.QualifiedName() +} + +// SetDocumentTemplateQualifiedName sets the value of the documentTemplate property. +func (o *GenerateDocumentAction) SetDocumentTemplateQualifiedName(v string) { + o.documentTemplate.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *GenerateDocumentAction) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *GenerateDocumentAction) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *GenerateDocumentAction) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// OverrideTopMargin returns the value of the overrideTopMargin property. +func (o *GenerateDocumentAction) OverrideTopMargin() bool { + return o.overrideTopMargin.Get() +} + +// SetOverrideTopMargin sets the value of the overrideTopMargin property. +func (o *GenerateDocumentAction) SetOverrideTopMargin(v bool) { + o.overrideTopMargin.Set(v) +} + +// OverrideBottomMargin returns the value of the overrideBottomMargin property. +func (o *GenerateDocumentAction) OverrideBottomMargin() bool { + return o.overrideBottomMargin.Get() +} + +// SetOverrideBottomMargin sets the value of the overrideBottomMargin property. +func (o *GenerateDocumentAction) SetOverrideBottomMargin(v bool) { + o.overrideBottomMargin.Set(v) +} + +// OverrideLeftMargin returns the value of the overrideLeftMargin property. +func (o *GenerateDocumentAction) OverrideLeftMargin() bool { + return o.overrideLeftMargin.Get() +} + +// SetOverrideLeftMargin sets the value of the overrideLeftMargin property. +func (o *GenerateDocumentAction) SetOverrideLeftMargin(v bool) { + o.overrideLeftMargin.Set(v) +} + +// OverrideRightMargin returns the value of the overrideRightMargin property. +func (o *GenerateDocumentAction) OverrideRightMargin() bool { + return o.overrideRightMargin.Get() +} + +// SetOverrideRightMargin sets the value of the overrideRightMargin property. +func (o *GenerateDocumentAction) SetOverrideRightMargin(v bool) { + o.overrideRightMargin.Set(v) +} + +// MarginLeftInInch returns the value of the marginLeftInInch property. +func (o *GenerateDocumentAction) MarginLeftInInch() string { + return o.marginLeftInInch.Get() +} + +// SetMarginLeftInInch sets the value of the marginLeftInInch property. +func (o *GenerateDocumentAction) SetMarginLeftInInch(v string) { + o.marginLeftInInch.Set(v) +} + +// MarginLeftInInchModel returns the value of the marginLeftInInchModel property. +func (o *GenerateDocumentAction) MarginLeftInInchModel() element.Element { + return o.marginLeftInInchModel.Get() +} + +// SetMarginLeftInInchModel sets the value of the marginLeftInInchModel property. +func (o *GenerateDocumentAction) SetMarginLeftInInchModel(v element.Element) { + o.marginLeftInInchModel.Set(v) +} + +// MarginRightInInch returns the value of the marginRightInInch property. +func (o *GenerateDocumentAction) MarginRightInInch() string { + return o.marginRightInInch.Get() +} + +// SetMarginRightInInch sets the value of the marginRightInInch property. +func (o *GenerateDocumentAction) SetMarginRightInInch(v string) { + o.marginRightInInch.Set(v) +} + +// MarginRightInInchModel returns the value of the marginRightInInchModel property. +func (o *GenerateDocumentAction) MarginRightInInchModel() element.Element { + return o.marginRightInInchModel.Get() +} + +// SetMarginRightInInchModel sets the value of the marginRightInInchModel property. +func (o *GenerateDocumentAction) SetMarginRightInInchModel(v element.Element) { + o.marginRightInInchModel.Set(v) +} + +// MarginTopInInch returns the value of the marginTopInInch property. +func (o *GenerateDocumentAction) MarginTopInInch() string { + return o.marginTopInInch.Get() +} + +// SetMarginTopInInch sets the value of the marginTopInInch property. +func (o *GenerateDocumentAction) SetMarginTopInInch(v string) { + o.marginTopInInch.Set(v) +} + +// MarginTopInInchModel returns the value of the marginTopInInchModel property. +func (o *GenerateDocumentAction) MarginTopInInchModel() element.Element { + return o.marginTopInInchModel.Get() +} + +// SetMarginTopInInchModel sets the value of the marginTopInInchModel property. +func (o *GenerateDocumentAction) SetMarginTopInInchModel(v element.Element) { + o.marginTopInInchModel.Set(v) +} + +// MarginBottomInInch returns the value of the marginBottomInInch property. +func (o *GenerateDocumentAction) MarginBottomInInch() string { + return o.marginBottomInInch.Get() +} + +// SetMarginBottomInInch sets the value of the marginBottomInInch property. +func (o *GenerateDocumentAction) SetMarginBottomInInch(v string) { + o.marginBottomInInch.Set(v) +} + +// MarginBottomInInchModel returns the value of the marginBottomInInchModel property. +func (o *GenerateDocumentAction) MarginBottomInInchModel() element.Element { + return o.marginBottomInInchModel.Get() +} + +// SetMarginBottomInInchModel sets the value of the marginBottomInInchModel property. +func (o *GenerateDocumentAction) SetMarginBottomInInchModel(v element.Element) { + o.marginBottomInInchModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GenerateDocumentAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.fileVariableName.Init(raw) + o.languageVariableName.Init(raw) + if val, err := raw.LookupErr("DocumentType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.documentType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("LanguageSetting"); err == nil { + if s, ok := val.StringValueOK(); ok { o.languageSetting.SetFromDecode(s) } + } + if val, err := raw.LookupErr("DocumentTemplate"); err == nil { + if s, ok := val.StringValueOK(); ok { o.documentTemplate.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + o.overrideTopMargin.Init(raw) + o.overrideBottomMargin.Init(raw) + o.overrideLeftMargin.Init(raw) + o.overrideRightMargin.Init(raw) + o.marginLeftInInch.Init(raw) + if child, err := codec.DecodeChild(raw, "MarginLeftInInchModel"); err == nil { + o.marginLeftInInchModel.SetFromDecode(child) + } + o.marginRightInInch.Init(raw) + if child, err := codec.DecodeChild(raw, "MarginRightInInchModel"); err == nil { + o.marginRightInInchModel.SetFromDecode(child) + } + o.marginTopInInch.Init(raw) + if child, err := codec.DecodeChild(raw, "MarginTopInInchModel"); err == nil { + o.marginTopInInchModel.SetFromDecode(child) + } + o.marginBottomInInch.Init(raw) + if child, err := codec.DecodeChild(raw, "MarginBottomInInchModel"); err == nil { + o.marginBottomInInchModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// GenerateJumpToOptionsAction +// ──────────────────────────────────────────────────────── + +type GenerateJumpToOptionsAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflowVariable *property.Primitive[string] + workflow *property.ByNameRef[element.Element] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *GenerateJumpToOptionsAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *GenerateJumpToOptionsAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *GenerateJumpToOptionsAction) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *GenerateJumpToOptionsAction) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// WorkflowQualifiedName returns the value of the workflow property. +func (o *GenerateJumpToOptionsAction) WorkflowQualifiedName() string { + return o.workflow.QualifiedName() +} + +// SetWorkflowQualifiedName sets the value of the workflow property. +func (o *GenerateJumpToOptionsAction) SetWorkflowQualifiedName(v string) { + o.workflow.SetQualifiedName(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *GenerateJumpToOptionsAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *GenerateJumpToOptionsAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GenerateJumpToOptionsAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.workflowVariable.Init(raw) + if val, err := raw.LookupErr("Workflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.workflow.SetFromDecode(s) } + } + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// GetWorkflowActivityRecordsAction +// ──────────────────────────────────────────────────────── + +type GetWorkflowActivityRecordsAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflowVariable *property.Primitive[string] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *GetWorkflowActivityRecordsAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *GetWorkflowActivityRecordsAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *GetWorkflowActivityRecordsAction) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *GetWorkflowActivityRecordsAction) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *GetWorkflowActivityRecordsAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *GetWorkflowActivityRecordsAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GetWorkflowActivityRecordsAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.workflowVariable.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// GetWorkflowDataAction +// ──────────────────────────────────────────────────────── + +type GetWorkflowDataAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflowVariable *property.Primitive[string] + workflow *property.ByNameRef[element.Element] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *GetWorkflowDataAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *GetWorkflowDataAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *GetWorkflowDataAction) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *GetWorkflowDataAction) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// WorkflowQualifiedName returns the value of the workflow property. +func (o *GetWorkflowDataAction) WorkflowQualifiedName() string { + return o.workflow.QualifiedName() +} + +// SetWorkflowQualifiedName sets the value of the workflow property. +func (o *GetWorkflowDataAction) SetWorkflowQualifiedName(v string) { + o.workflow.SetQualifiedName(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *GetWorkflowDataAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *GetWorkflowDataAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GetWorkflowDataAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.workflowVariable.Init(raw) + if val, err := raw.LookupErr("Workflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.workflow.SetFromDecode(s) } + } + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// GetWorkflowsAction +// ──────────────────────────────────────────────────────── + +type GetWorkflowsAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflowContextVariableName *property.Primitive[string] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *GetWorkflowsAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *GetWorkflowsAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowContextVariableName returns the value of the workflowContextVariableName property. +func (o *GetWorkflowsAction) WorkflowContextVariableName() string { + return o.workflowContextVariableName.Get() +} + +// SetWorkflowContextVariableName sets the value of the workflowContextVariableName property. +func (o *GetWorkflowsAction) SetWorkflowContextVariableName(v string) { + o.workflowContextVariableName.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *GetWorkflowsAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *GetWorkflowsAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GetWorkflowsAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.workflowContextVariableName.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Head +// ──────────────────────────────────────────────────────── + +type Head struct { + element.Base + listVariableName *property.Primitive[string] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *Head) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *Head) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Head) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// HttpConfiguration +// ──────────────────────────────────────────────────────── + +type HttpConfiguration struct { + element.Base + overrideLocation *property.Primitive[bool] + customLocation *property.Primitive[string] + customLocationModel *property.Part[element.Element] + customLocationTemplate *property.Part[element.Element] + useAuthentication *property.Primitive[bool] + httpAuthenticationUserName *property.Primitive[string] + username *property.Part[element.Element] + authenticationPassword *property.Primitive[string] + password *property.Part[element.Element] + headerEntries *property.PartList[element.Element] + httpMethod *property.Enum[string] + newHttpMethod *property.Enum[string] + clientCertificate *property.Primitive[string] +} + +// OverrideLocation returns the value of the overrideLocation property. +func (o *HttpConfiguration) OverrideLocation() bool { + return o.overrideLocation.Get() +} + +// SetOverrideLocation sets the value of the overrideLocation property. +func (o *HttpConfiguration) SetOverrideLocation(v bool) { + o.overrideLocation.Set(v) +} + +// CustomLocation returns the value of the customLocation property. +func (o *HttpConfiguration) CustomLocation() string { + return o.customLocation.Get() +} + +// SetCustomLocation sets the value of the customLocation property. +func (o *HttpConfiguration) SetCustomLocation(v string) { + o.customLocation.Set(v) +} + +// CustomLocationModel returns the value of the customLocationModel property. +func (o *HttpConfiguration) CustomLocationModel() element.Element { + return o.customLocationModel.Get() +} + +// SetCustomLocationModel sets the value of the customLocationModel property. +func (o *HttpConfiguration) SetCustomLocationModel(v element.Element) { + o.customLocationModel.Set(v) +} + +// CustomLocationTemplate returns the value of the customLocationTemplate property. +func (o *HttpConfiguration) CustomLocationTemplate() element.Element { + return o.customLocationTemplate.Get() +} + +// SetCustomLocationTemplate sets the value of the customLocationTemplate property. +func (o *HttpConfiguration) SetCustomLocationTemplate(v element.Element) { + o.customLocationTemplate.Set(v) +} + +// UseAuthentication returns the value of the useAuthentication property. +func (o *HttpConfiguration) UseAuthentication() bool { + return o.useAuthentication.Get() +} + +// SetUseAuthentication sets the value of the useAuthentication property. +func (o *HttpConfiguration) SetUseAuthentication(v bool) { + o.useAuthentication.Set(v) +} + +// HttpAuthenticationUserName returns the value of the httpAuthenticationUserName property. +func (o *HttpConfiguration) HttpAuthenticationUserName() string { + return o.httpAuthenticationUserName.Get() +} + +// SetHttpAuthenticationUserName sets the value of the httpAuthenticationUserName property. +func (o *HttpConfiguration) SetHttpAuthenticationUserName(v string) { + o.httpAuthenticationUserName.Set(v) +} + +// Username returns the value of the username property. +func (o *HttpConfiguration) Username() element.Element { + return o.username.Get() +} + +// SetUsername sets the value of the username property. +func (o *HttpConfiguration) SetUsername(v element.Element) { + o.username.Set(v) +} + +// AuthenticationPassword returns the value of the authenticationPassword property. +func (o *HttpConfiguration) AuthenticationPassword() string { + return o.authenticationPassword.Get() +} + +// SetAuthenticationPassword sets the value of the authenticationPassword property. +func (o *HttpConfiguration) SetAuthenticationPassword(v string) { + o.authenticationPassword.Set(v) +} + +// Password returns the value of the password property. +func (o *HttpConfiguration) Password() element.Element { + return o.password.Get() +} + +// SetPassword sets the value of the password property. +func (o *HttpConfiguration) SetPassword(v element.Element) { + o.password.Set(v) +} + +// HeaderEntriesItems returns the value of the headerEntries property. +func (o *HttpConfiguration) HeaderEntriesItems() []element.Element { + return o.headerEntries.Items() +} + +// AddHeaderEntries appends a child element to the headerEntries list. +func (o *HttpConfiguration) AddHeaderEntries(v element.Element) { + o.headerEntries.Append(v) +} + +// RemoveHeaderEntries removes the element at the given index from the headerEntries list. +func (o *HttpConfiguration) RemoveHeaderEntries(index int) { + o.headerEntries.Remove(index) +} + +// HttpMethod returns the value of the httpMethod property. +func (o *HttpConfiguration) HttpMethod() string { + return o.httpMethod.Get() +} + +// SetHttpMethod sets the value of the httpMethod property. +func (o *HttpConfiguration) SetHttpMethod(v string) { + o.httpMethod.Set(v) +} + +// NewHttpMethod returns the value of the newHttpMethod property. +func (o *HttpConfiguration) NewHttpMethod() string { + return o.newHttpMethod.Get() +} + +// SetNewHttpMethod sets the value of the newHttpMethod property. +func (o *HttpConfiguration) SetNewHttpMethod(v string) { + o.newHttpMethod.Set(v) +} + +// ClientCertificate returns the value of the clientCertificate property. +func (o *HttpConfiguration) ClientCertificate() string { + return o.clientCertificate.Get() +} + +// SetClientCertificate sets the value of the clientCertificate property. +func (o *HttpConfiguration) SetClientCertificate(v string) { + o.clientCertificate.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *HttpConfiguration) InitFromRaw(raw bson.Raw) { + o.overrideLocation.Init(raw) + o.customLocation.Init(raw) + if child, err := codec.DecodeChild(raw, "CustomLocationModel"); err == nil { + o.customLocationModel.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "CustomLocationTemplate"); err == nil { + o.customLocationTemplate.SetFromDecode(child) + } + o.useAuthentication.Init(raw) + o.httpAuthenticationUserName.Init(raw) + if child, err := codec.DecodeChild(raw, "Username"); err == nil { + o.username.SetFromDecode(child) + } + o.authenticationPassword.Init(raw) + if child, err := codec.DecodeChild(raw, "Password"); err == nil { + o.password.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "HeaderEntries"); err == nil { + for _, child := range children { + o.headerEntries.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("HttpMethod"); err == nil { + if s, ok := val.StringValueOK(); ok { o.httpMethod.SetFromDecode(s) } + } + if val, err := raw.LookupErr("NewHttpMethod"); err == nil { + if s, ok := val.StringValueOK(); ok { o.newHttpMethod.SetFromDecode(s) } + } + o.clientCertificate.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// HttpHeaderEntry +// ──────────────────────────────────────────────────────── + +type HttpHeaderEntry struct { + element.Base + key *property.Primitive[string] + value *property.Primitive[string] + valueModel *property.Part[element.Element] +} + +// Key returns the value of the key property. +func (o *HttpHeaderEntry) Key() string { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *HttpHeaderEntry) SetKey(v string) { + o.key.Set(v) +} + +// Value returns the value of the value property. +func (o *HttpHeaderEntry) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *HttpHeaderEntry) SetValue(v string) { + o.value.Set(v) +} + +// ValueModel returns the value of the valueModel property. +func (o *HttpHeaderEntry) ValueModel() element.Element { + return o.valueModel.Get() +} + +// SetValueModel sets the value of the valueModel property. +func (o *HttpHeaderEntry) SetValueModel(v element.Element) { + o.valueModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *HttpHeaderEntry) InitFromRaw(raw bson.Raw) { + o.key.Init(raw) + o.value.Init(raw) + if child, err := codec.DecodeChild(raw, "ValueModel"); err == nil { + o.valueModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ImportMappingCall +// ──────────────────────────────────────────────────────── + +type ImportMappingCall struct { + element.Base + mapping *property.ByNameRef[element.Element] + objectHandlingBackup *property.Enum[string] + commit *property.Enum[string] + mappingArgumentVariableName *property.Primitive[string] + propRange *property.Part[element.Element] + contentType *property.Enum[string] + forceSingleOccurrence *property.Primitive[bool] +} + +// MappingQualifiedName returns the value of the mapping property. +func (o *ImportMappingCall) MappingQualifiedName() string { + return o.mapping.QualifiedName() +} + +// SetMappingQualifiedName sets the value of the mapping property. +func (o *ImportMappingCall) SetMappingQualifiedName(v string) { + o.mapping.SetQualifiedName(v) +} + +// ObjectHandlingBackup returns the value of the objectHandlingBackup property. +func (o *ImportMappingCall) ObjectHandlingBackup() string { + return o.objectHandlingBackup.Get() +} + +// SetObjectHandlingBackup sets the value of the objectHandlingBackup property. +func (o *ImportMappingCall) SetObjectHandlingBackup(v string) { + o.objectHandlingBackup.Set(v) +} + +// Commit returns the value of the commit property. +func (o *ImportMappingCall) Commit() string { + return o.commit.Get() +} + +// SetCommit sets the value of the commit property. +func (o *ImportMappingCall) SetCommit(v string) { + o.commit.Set(v) +} + +// MappingArgumentVariableName returns the value of the mappingArgumentVariableName property. +func (o *ImportMappingCall) MappingArgumentVariableName() string { + return o.mappingArgumentVariableName.Get() +} + +// SetMappingArgumentVariableName sets the value of the mappingArgumentVariableName property. +func (o *ImportMappingCall) SetMappingArgumentVariableName(v string) { + o.mappingArgumentVariableName.Set(v) +} + +// Range returns the value of the range property. +func (o *ImportMappingCall) Range() element.Element { + return o.propRange.Get() +} + +// SetRange sets the value of the range property. +func (o *ImportMappingCall) SetRange(v element.Element) { + o.propRange.Set(v) +} + +// ContentType returns the value of the contentType property. +func (o *ImportMappingCall) ContentType() string { + return o.contentType.Get() +} + +// SetContentType sets the value of the contentType property. +func (o *ImportMappingCall) SetContentType(v string) { + o.contentType.Set(v) +} + +// ForceSingleOccurrence returns the value of the forceSingleOccurrence property. +func (o *ImportMappingCall) ForceSingleOccurrence() bool { + return o.forceSingleOccurrence.Get() +} + +// SetForceSingleOccurrence sets the value of the forceSingleOccurrence property. +func (o *ImportMappingCall) SetForceSingleOccurrence(v bool) { + o.forceSingleOccurrence.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportMappingCall) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Mapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.mapping.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ObjectHandlingBackup"); err == nil { + if s, ok := val.StringValueOK(); ok { o.objectHandlingBackup.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Commit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.commit.SetFromDecode(s) } + } + o.mappingArgumentVariableName.Init(raw) + if child, err := codec.DecodeChild(raw, "Range"); err == nil { + o.propRange.SetFromDecode(child) + } + if val, err := raw.LookupErr("ContentType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.contentType.SetFromDecode(s) } + } + o.forceSingleOccurrence.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ImportMappingJavaActionParameterValue +// ──────────────────────────────────────────────────────── + +type ImportMappingJavaActionParameterValue struct { + element.Base + importMapping *property.ByNameRef[element.Element] +} + +// ImportMappingQualifiedName returns the value of the importMapping property. +func (o *ImportMappingJavaActionParameterValue) ImportMappingQualifiedName() string { + return o.importMapping.QualifiedName() +} + +// SetImportMappingQualifiedName sets the value of the importMapping property. +func (o *ImportMappingJavaActionParameterValue) SetImportMappingQualifiedName(v string) { + o.importMapping.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportMappingJavaActionParameterValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ImportMapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.importMapping.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ImportMappingParameterValue +// ──────────────────────────────────────────────────────── + +type ImportMappingParameterValue struct { + element.Base + importMapping *property.ByNameRef[element.Element] +} + +// ImportMappingQualifiedName returns the value of the importMapping property. +func (o *ImportMappingParameterValue) ImportMappingQualifiedName() string { + return o.importMapping.QualifiedName() +} + +// SetImportMappingQualifiedName sets the value of the importMapping property. +func (o *ImportMappingParameterValue) SetImportMappingQualifiedName(v string) { + o.importMapping.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportMappingParameterValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ImportMapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.importMapping.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ImportXmlAction +// ──────────────────────────────────────────────────────── + +type ImportXmlAction struct { + element.Base + errorHandlingType *property.Enum[string] + xmlDocumentVariableName *property.Primitive[string] + resultHandling *property.Part[element.Element] + isValidationRequired *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ImportXmlAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ImportXmlAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// XmlDocumentVariableName returns the value of the xmlDocumentVariableName property. +func (o *ImportXmlAction) XmlDocumentVariableName() string { + return o.xmlDocumentVariableName.Get() +} + +// SetXmlDocumentVariableName sets the value of the xmlDocumentVariableName property. +func (o *ImportXmlAction) SetXmlDocumentVariableName(v string) { + o.xmlDocumentVariableName.Set(v) +} + +// ResultHandling returns the value of the resultHandling property. +func (o *ImportXmlAction) ResultHandling() element.Element { + return o.resultHandling.Get() +} + +// SetResultHandling sets the value of the resultHandling property. +func (o *ImportXmlAction) SetResultHandling(v element.Element) { + o.resultHandling.Set(v) +} + +// IsValidationRequired returns the value of the isValidationRequired property. +func (o *ImportXmlAction) IsValidationRequired() bool { + return o.isValidationRequired.Get() +} + +// SetIsValidationRequired sets the value of the isValidationRequired property. +func (o *ImportXmlAction) SetIsValidationRequired(v bool) { + o.isValidationRequired.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportXmlAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.xmlDocumentVariableName.Init(raw) + if child, err := codec.DecodeChild(raw, "ResultHandling"); err == nil { + o.resultHandling.SetFromDecode(child) + } + o.isValidationRequired.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// IncludedAssociation +// ──────────────────────────────────────────────────────── + +type IncludedAssociation struct { + element.Base + association *property.ByNameRef[element.Element] + isParent *property.Primitive[bool] + includedAssociations *property.PartList[element.Element] +} + +// AssociationQualifiedName returns the value of the association property. +func (o *IncludedAssociation) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *IncludedAssociation) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// IsParent returns the value of the isParent property. +func (o *IncludedAssociation) IsParent() bool { + return o.isParent.Get() +} + +// SetIsParent sets the value of the isParent property. +func (o *IncludedAssociation) SetIsParent(v bool) { + o.isParent.Set(v) +} + +// IncludedAssociationsItems returns the value of the includedAssociations property. +func (o *IncludedAssociation) IncludedAssociationsItems() []element.Element { + return o.includedAssociations.Items() +} + +// AddIncludedAssociations appends a child element to the includedAssociations list. +func (o *IncludedAssociation) AddIncludedAssociations(v element.Element) { + o.includedAssociations.Append(v) +} + +// RemoveIncludedAssociations removes the element at the given index from the includedAssociations list. +func (o *IncludedAssociation) RemoveIncludedAssociations(index int) { + o.includedAssociations.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IncludedAssociation) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { o.association.SetFromDecode(s) } + } + o.isParent.Init(raw) + if children, err := codec.DecodeChildren(raw, "IncludedAssociations"); err == nil { + for _, child := range children { + o.includedAssociations.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// IncrementCounterMeterAction +// ──────────────────────────────────────────────────────── + +type IncrementCounterMeterAction struct { + element.Base + errorHandlingType *property.Enum[string] + name *property.Primitive[string] + description *property.Primitive[string] + tags *property.PartList[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *IncrementCounterMeterAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *IncrementCounterMeterAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Name returns the value of the name property. +func (o *IncrementCounterMeterAction) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *IncrementCounterMeterAction) SetName(v string) { + o.name.Set(v) +} + +// Description returns the value of the description property. +func (o *IncrementCounterMeterAction) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *IncrementCounterMeterAction) SetDescription(v string) { + o.description.Set(v) +} + +// TagsItems returns the value of the tags property. +func (o *IncrementCounterMeterAction) TagsItems() []element.Element { + return o.tags.Items() +} + +// AddTags appends a child element to the tags list. +func (o *IncrementCounterMeterAction) AddTags(v element.Element) { + o.tags.Append(v) +} + +// RemoveTags removes the element at the given index from the tags list. +func (o *IncrementCounterMeterAction) RemoveTags(index int) { + o.tags.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IncrementCounterMeterAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.name.Init(raw) + o.description.Init(raw) + if children, err := codec.DecodeChildren(raw, "Tags"); err == nil { + for _, child := range children { + o.tags.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// InheritanceCase +// ──────────────────────────────────────────────────────── + +type InheritanceCase struct { + element.Base + value *property.ByNameRef[element.Element] +} + +// ValueQualifiedName returns the value of the value property. +func (o *InheritanceCase) ValueQualifiedName() string { + return o.value.QualifiedName() +} + +// SetValueQualifiedName sets the value of the value property. +func (o *InheritanceCase) SetValueQualifiedName(v string) { + o.value.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *InheritanceCase) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Value"); err == nil { + if s, ok := val.StringValueOK(); ok { o.value.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// InheritanceSplit +// ──────────────────────────────────────────────────────── + +type InheritanceSplit struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + splitVariableName *property.Primitive[string] + caption *property.Primitive[string] + documentation *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *InheritanceSplit) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *InheritanceSplit) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *InheritanceSplit) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *InheritanceSplit) SetSize(v string) { + o.size.Set(v) +} + +// SplitVariableName returns the value of the splitVariableName property. +func (o *InheritanceSplit) SplitVariableName() string { + return o.splitVariableName.Get() +} + +// SetSplitVariableName sets the value of the splitVariableName property. +func (o *InheritanceSplit) SetSplitVariableName(v string) { + o.splitVariableName.Set(v) +} + +// Caption returns the value of the caption property. +func (o *InheritanceSplit) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *InheritanceSplit) SetCaption(v string) { + o.caption.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *InheritanceSplit) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *InheritanceSplit) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *InheritanceSplit) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + o.splitVariableName.Init(raw) + o.caption.Init(raw) + o.documentation.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Intersect +// ──────────────────────────────────────────────────────── + +type Intersect struct { + element.Base + listVariableName *property.Primitive[string] + secondListOrObjectVariableName *property.Primitive[string] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *Intersect) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *Intersect) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// SecondListOrObjectVariableName returns the value of the secondListOrObjectVariableName property. +func (o *Intersect) SecondListOrObjectVariableName() string { + return o.secondListOrObjectVariableName.Get() +} + +// SetSecondListOrObjectVariableName sets the value of the secondListOrObjectVariableName property. +func (o *Intersect) SetSecondListOrObjectVariableName(v string) { + o.secondListOrObjectVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Intersect) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.secondListOrObjectVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LoopSource +// ──────────────────────────────────────────────────────── + +type LoopSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LoopSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// IterableList +// ──────────────────────────────────────────────────────── + +type IterableList struct { + element.Base + listVariableName *property.Primitive[string] + variableName *property.Primitive[string] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *IterableList) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *IterableList) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// VariableName returns the value of the variableName property. +func (o *IterableList) VariableName() string { + return o.variableName.Get() +} + +// SetVariableName sets the value of the variableName property. +func (o *IterableList) SetVariableName(v string) { + o.variableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IterableList) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.variableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// JavaActionCallAction +// ──────────────────────────────────────────────────────── + +type JavaActionCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + javaAction *property.ByNameRef[element.Element] + queueSettings *property.Part[element.Element] + queue *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] + useReturnVariable *property.Primitive[bool] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *JavaActionCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *JavaActionCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// JavaActionQualifiedName returns the value of the javaAction property. +func (o *JavaActionCallAction) JavaActionQualifiedName() string { + return o.javaAction.QualifiedName() +} + +// SetJavaActionQualifiedName sets the value of the javaAction property. +func (o *JavaActionCallAction) SetJavaActionQualifiedName(v string) { + o.javaAction.SetQualifiedName(v) +} + +// QueueSettings returns the value of the queueSettings property. +func (o *JavaActionCallAction) QueueSettings() element.Element { + return o.queueSettings.Get() +} + +// SetQueueSettings sets the value of the queueSettings property. +func (o *JavaActionCallAction) SetQueueSettings(v element.Element) { + o.queueSettings.Set(v) +} + +// QueueQualifiedName returns the value of the queue property. +func (o *JavaActionCallAction) QueueQualifiedName() string { + return o.queue.QualifiedName() +} + +// SetQueueQualifiedName sets the value of the queue property. +func (o *JavaActionCallAction) SetQueueQualifiedName(v string) { + o.queue.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *JavaActionCallAction) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *JavaActionCallAction) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *JavaActionCallAction) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// UseReturnVariable returns the value of the useReturnVariable property. +func (o *JavaActionCallAction) UseReturnVariable() bool { + return o.useReturnVariable.Get() +} + +// SetUseReturnVariable sets the value of the useReturnVariable property. +func (o *JavaActionCallAction) SetUseReturnVariable(v bool) { + o.useReturnVariable.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *JavaActionCallAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *JavaActionCallAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaActionCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("JavaAction"); err == nil { + if s, ok := val.StringValueOK(); ok { o.javaAction.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "QueueSettings"); err == nil { + o.queueSettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Queue"); err == nil { + if s, ok := val.StringValueOK(); ok { o.queue.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + o.useReturnVariable.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// JavaActionParameterMapping +// ──────────────────────────────────────────────────────── + +type JavaActionParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + argument *property.Primitive[string] + value *property.Part[element.Element] + parameterValue *property.Part[element.Element] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *JavaActionParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *JavaActionParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Argument returns the value of the argument property. +func (o *JavaActionParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *JavaActionParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// Value returns the value of the value property. +func (o *JavaActionParameterMapping) Value() element.Element { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *JavaActionParameterMapping) SetValue(v element.Element) { + o.value.Set(v) +} + +// ParameterValue returns the value of the parameterValue property. +func (o *JavaActionParameterMapping) ParameterValue() element.Element { + return o.parameterValue.Get() +} + +// SetParameterValue sets the value of the parameterValue property. +func (o *JavaActionParameterMapping) SetParameterValue(v element.Element) { + o.parameterValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaActionParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "Value"); err == nil { + o.value.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ParameterValue"); err == nil { + o.parameterValue.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// JavaScriptActionCallAction +// ──────────────────────────────────────────────────────── + +type JavaScriptActionCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + javaScriptAction *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] + useReturnVariable *property.Primitive[bool] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *JavaScriptActionCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *JavaScriptActionCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// JavaScriptActionQualifiedName returns the value of the javaScriptAction property. +func (o *JavaScriptActionCallAction) JavaScriptActionQualifiedName() string { + return o.javaScriptAction.QualifiedName() +} + +// SetJavaScriptActionQualifiedName sets the value of the javaScriptAction property. +func (o *JavaScriptActionCallAction) SetJavaScriptActionQualifiedName(v string) { + o.javaScriptAction.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *JavaScriptActionCallAction) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *JavaScriptActionCallAction) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *JavaScriptActionCallAction) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// UseReturnVariable returns the value of the useReturnVariable property. +func (o *JavaScriptActionCallAction) UseReturnVariable() bool { + return o.useReturnVariable.Get() +} + +// SetUseReturnVariable sets the value of the useReturnVariable property. +func (o *JavaScriptActionCallAction) SetUseReturnVariable(v bool) { + o.useReturnVariable.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *JavaScriptActionCallAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *JavaScriptActionCallAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaScriptActionCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("JavaScriptAction"); err == nil { + if s, ok := val.StringValueOK(); ok { o.javaScriptAction.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + o.useReturnVariable.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// JavaScriptActionParameterMapping +// ──────────────────────────────────────────────────────── + +type JavaScriptActionParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + parameterValue *property.Part[element.Element] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *JavaScriptActionParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *JavaScriptActionParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// ParameterValue returns the value of the parameterValue property. +func (o *JavaScriptActionParameterMapping) ParameterValue() element.Element { + return o.parameterValue.Get() +} + +// SetParameterValue sets the value of the parameterValue property. +func (o *JavaScriptActionParameterMapping) SetParameterValue(v element.Element) { + o.parameterValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaScriptActionParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ParameterValue"); err == nil { + o.parameterValue.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ListEquals +// ──────────────────────────────────────────────────────── + +type ListEquals struct { + element.Base + listVariableName *property.Primitive[string] + secondListOrObjectVariableName *property.Primitive[string] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *ListEquals) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *ListEquals) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// SecondListOrObjectVariableName returns the value of the secondListOrObjectVariableName property. +func (o *ListEquals) SecondListOrObjectVariableName() string { + return o.secondListOrObjectVariableName.Get() +} + +// SetSecondListOrObjectVariableName sets the value of the secondListOrObjectVariableName property. +func (o *ListEquals) SetSecondListOrObjectVariableName(v string) { + o.secondListOrObjectVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListEquals) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.secondListOrObjectVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ListOperationAction +// ──────────────────────────────────────────────────────── + +type ListOperationAction struct { + element.Base + errorHandlingType *property.Enum[string] + operation *property.Part[element.Element] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ListOperationAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ListOperationAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Operation returns the value of the operation property. +func (o *ListOperationAction) Operation() element.Element { + return o.operation.Get() +} + +// SetOperation sets the value of the operation property. +func (o *ListOperationAction) SetOperation(v element.Element) { + o.operation.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *ListOperationAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *ListOperationAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListOperationAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Operation"); err == nil { + o.operation.SetFromDecode(child) + } + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ListRange +// ──────────────────────────────────────────────────────── + +type ListRange struct { + element.Base + listVariableName *property.Primitive[string] + customRange *property.Part[element.Element] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *ListRange) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *ListRange) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// CustomRange returns the value of the customRange property. +func (o *ListRange) CustomRange() element.Element { + return o.customRange.Get() +} + +// SetCustomRange sets the value of the customRange property. +func (o *ListRange) SetCustomRange(v element.Element) { + o.customRange.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListRange) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + if child, err := codec.DecodeChild(raw, "CustomRange"); err == nil { + o.customRange.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// LockWorkflowAction +// ──────────────────────────────────────────────────────── + +type LockWorkflowAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflow *property.ByNameRef[element.Element] + workflowSelection *property.Part[element.Element] + pauseAllWorkflows *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *LockWorkflowAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *LockWorkflowAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowQualifiedName returns the value of the workflow property. +func (o *LockWorkflowAction) WorkflowQualifiedName() string { + return o.workflow.QualifiedName() +} + +// SetWorkflowQualifiedName sets the value of the workflow property. +func (o *LockWorkflowAction) SetWorkflowQualifiedName(v string) { + o.workflow.SetQualifiedName(v) +} + +// WorkflowSelection returns the value of the workflowSelection property. +func (o *LockWorkflowAction) WorkflowSelection() element.Element { + return o.workflowSelection.Get() +} + +// SetWorkflowSelection sets the value of the workflowSelection property. +func (o *LockWorkflowAction) SetWorkflowSelection(v element.Element) { + o.workflowSelection.Set(v) +} + +// PauseAllWorkflows returns the value of the pauseAllWorkflows property. +func (o *LockWorkflowAction) PauseAllWorkflows() bool { + return o.pauseAllWorkflows.Get() +} + +// SetPauseAllWorkflows sets the value of the pauseAllWorkflows property. +func (o *LockWorkflowAction) SetPauseAllWorkflows(v bool) { + o.pauseAllWorkflows.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LockWorkflowAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Workflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.workflow.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "WorkflowSelection"); err == nil { + o.workflowSelection.SetFromDecode(child) + } + o.pauseAllWorkflows.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LogMessageAction +// ──────────────────────────────────────────────────────── + +type LogMessageAction struct { + element.Base + errorHandlingType *property.Enum[string] + level *property.Enum[string] + node *property.Primitive[string] + nodeModel *property.Part[element.Element] + messageTemplate *property.Part[element.Element] + includeLatestStackTrace *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *LogMessageAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *LogMessageAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Level returns the value of the level property. +func (o *LogMessageAction) Level() string { + return o.level.Get() +} + +// SetLevel sets the value of the level property. +func (o *LogMessageAction) SetLevel(v string) { + o.level.Set(v) +} + +// Node returns the value of the node property. +func (o *LogMessageAction) Node() string { + return o.node.Get() +} + +// SetNode sets the value of the node property. +func (o *LogMessageAction) SetNode(v string) { + o.node.Set(v) +} + +// NodeModel returns the value of the nodeModel property. +func (o *LogMessageAction) NodeModel() element.Element { + return o.nodeModel.Get() +} + +// SetNodeModel sets the value of the nodeModel property. +func (o *LogMessageAction) SetNodeModel(v element.Element) { + o.nodeModel.Set(v) +} + +// MessageTemplate returns the value of the messageTemplate property. +func (o *LogMessageAction) MessageTemplate() element.Element { + return o.messageTemplate.Get() +} + +// SetMessageTemplate sets the value of the messageTemplate property. +func (o *LogMessageAction) SetMessageTemplate(v element.Element) { + o.messageTemplate.Set(v) +} + +// IncludeLatestStackTrace returns the value of the includeLatestStackTrace property. +func (o *LogMessageAction) IncludeLatestStackTrace() bool { + return o.includeLatestStackTrace.Get() +} + +// SetIncludeLatestStackTrace sets the value of the includeLatestStackTrace property. +func (o *LogMessageAction) SetIncludeLatestStackTrace(v bool) { + o.includeLatestStackTrace.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LogMessageAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Level"); err == nil { + if s, ok := val.StringValueOK(); ok { o.level.SetFromDecode(s) } + } + o.node.Init(raw) + if child, err := codec.DecodeChild(raw, "NodeModel"); err == nil { + o.nodeModel.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "MessageTemplate"); err == nil { + o.messageTemplate.SetFromDecode(child) + } + o.includeLatestStackTrace.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LoopedActivity +// ──────────────────────────────────────────────────────── + +type LoopedActivity struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + objectCollection *property.Part[element.Element] + iteratedListVariableName *property.Primitive[string] + loopVariableName *property.Primitive[string] + errorHandlingType *property.Enum[string] + documentation *property.Primitive[string] + loopSource *property.Part[element.Element] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *LoopedActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *LoopedActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *LoopedActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *LoopedActivity) SetSize(v string) { + o.size.Set(v) +} + +// ObjectCollection returns the value of the objectCollection property. +func (o *LoopedActivity) ObjectCollection() element.Element { + return o.objectCollection.Get() +} + +// SetObjectCollection sets the value of the objectCollection property. +func (o *LoopedActivity) SetObjectCollection(v element.Element) { + o.objectCollection.Set(v) +} + +// IteratedListVariableName returns the value of the iteratedListVariableName property. +func (o *LoopedActivity) IteratedListVariableName() string { + return o.iteratedListVariableName.Get() +} + +// SetIteratedListVariableName sets the value of the iteratedListVariableName property. +func (o *LoopedActivity) SetIteratedListVariableName(v string) { + o.iteratedListVariableName.Set(v) +} + +// LoopVariableName returns the value of the loopVariableName property. +func (o *LoopedActivity) LoopVariableName() string { + return o.loopVariableName.Get() +} + +// SetLoopVariableName sets the value of the loopVariableName property. +func (o *LoopedActivity) SetLoopVariableName(v string) { + o.loopVariableName.Set(v) +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *LoopedActivity) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *LoopedActivity) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *LoopedActivity) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *LoopedActivity) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// LoopSource returns the value of the loopSource property. +func (o *LoopedActivity) LoopSource() element.Element { + return o.loopSource.Get() +} + +// SetLoopSource sets the value of the loopSource property. +func (o *LoopedActivity) SetLoopSource(v element.Element) { + o.loopSource.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LoopedActivity) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if child, err := codec.DecodeChild(raw, "ObjectCollection"); err == nil { + o.objectCollection.SetFromDecode(child) + } + o.iteratedListVariableName.Init(raw) + o.loopVariableName.Init(raw) + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.documentation.Init(raw) + if child, err := codec.DecodeChild(raw, "LoopSource"); err == nil { + o.loopSource.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MLModelCall +// ──────────────────────────────────────────────────────── + +type MLModelCall struct { + element.Base + modelReference *property.Primitive[string] + mlMappingDocument *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] +} + +// ModelReference returns the value of the modelReference property. +func (o *MLModelCall) ModelReference() string { + return o.modelReference.Get() +} + +// SetModelReference sets the value of the modelReference property. +func (o *MLModelCall) SetModelReference(v string) { + o.modelReference.Set(v) +} + +// MlMappingDocumentQualifiedName returns the value of the mlMappingDocument property. +func (o *MLModelCall) MlMappingDocumentQualifiedName() string { + return o.mlMappingDocument.QualifiedName() +} + +// SetMlMappingDocumentQualifiedName sets the value of the mlMappingDocument property. +func (o *MLModelCall) SetMlMappingDocumentQualifiedName(v string) { + o.mlMappingDocument.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *MLModelCall) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *MLModelCall) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *MLModelCall) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MLModelCall) InitFromRaw(raw bson.Raw) { + o.modelReference.Init(raw) + if val, err := raw.LookupErr("MlMappingDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { o.mlMappingDocument.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MLModelCallAction +// ──────────────────────────────────────────────────────── + +type MLModelCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + modelCall *property.Part[element.Element] + mlMappingDocument *property.ByNameRef[element.Element] + inputVariableName *property.Primitive[string] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *MLModelCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *MLModelCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// ModelCall returns the value of the modelCall property. +func (o *MLModelCallAction) ModelCall() element.Element { + return o.modelCall.Get() +} + +// SetModelCall sets the value of the modelCall property. +func (o *MLModelCallAction) SetModelCall(v element.Element) { + o.modelCall.Set(v) +} + +// MlMappingDocumentQualifiedName returns the value of the mlMappingDocument property. +func (o *MLModelCallAction) MlMappingDocumentQualifiedName() string { + return o.mlMappingDocument.QualifiedName() +} + +// SetMlMappingDocumentQualifiedName sets the value of the mlMappingDocument property. +func (o *MLModelCallAction) SetMlMappingDocumentQualifiedName(v string) { + o.mlMappingDocument.SetQualifiedName(v) +} + +// InputVariableName returns the value of the inputVariableName property. +func (o *MLModelCallAction) InputVariableName() string { + return o.inputVariableName.Get() +} + +// SetInputVariableName sets the value of the inputVariableName property. +func (o *MLModelCallAction) SetInputVariableName(v string) { + o.inputVariableName.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *MLModelCallAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *MLModelCallAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MLModelCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ModelCall"); err == nil { + o.modelCall.SetFromDecode(child) + } + if val, err := raw.LookupErr("MlMappingDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { o.mlMappingDocument.SetFromDecode(s) } + } + o.inputVariableName.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MLModelCallParameterMapping +// ──────────────────────────────────────────────────────── + +type MLModelCallParameterMapping struct { + element.Base + parameterName *property.Primitive[string] + parameterType *property.Part[element.Element] + initialValue *property.Primitive[string] + initialValueModel *property.Primitive[string] +} + +// ParameterName returns the value of the parameterName property. +func (o *MLModelCallParameterMapping) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *MLModelCallParameterMapping) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *MLModelCallParameterMapping) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *MLModelCallParameterMapping) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// InitialValue returns the value of the initialValue property. +func (o *MLModelCallParameterMapping) InitialValue() string { + return o.initialValue.Get() +} + +// SetInitialValue sets the value of the initialValue property. +func (o *MLModelCallParameterMapping) SetInitialValue(v string) { + o.initialValue.Set(v) +} + +// InitialValueModel returns the value of the initialValueModel property. +func (o *MLModelCallParameterMapping) InitialValueModel() string { + return o.initialValueModel.Get() +} + +// SetInitialValueModel sets the value of the initialValueModel property. +func (o *MLModelCallParameterMapping) SetInitialValueModel(v string) { + o.initialValueModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MLModelCallParameterMapping) InitFromRaw(raw bson.Raw) { + o.parameterName.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } + o.initialValue.Init(raw) + o.initialValueModel.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MappingRequestHandling +// ──────────────────────────────────────────────────────── + +type MappingRequestHandling struct { + element.Base + mapping *property.ByNameRef[element.Element] + mappingArgumentVariableName *property.Primitive[string] + contentType *property.Enum[string] +} + +// MappingQualifiedName returns the value of the mapping property. +func (o *MappingRequestHandling) MappingQualifiedName() string { + return o.mapping.QualifiedName() +} + +// SetMappingQualifiedName sets the value of the mapping property. +func (o *MappingRequestHandling) SetMappingQualifiedName(v string) { + o.mapping.SetQualifiedName(v) +} + +// MappingArgumentVariableName returns the value of the mappingArgumentVariableName property. +func (o *MappingRequestHandling) MappingArgumentVariableName() string { + return o.mappingArgumentVariableName.Get() +} + +// SetMappingArgumentVariableName sets the value of the mappingArgumentVariableName property. +func (o *MappingRequestHandling) SetMappingArgumentVariableName(v string) { + o.mappingArgumentVariableName.Set(v) +} + +// ContentType returns the value of the contentType property. +func (o *MappingRequestHandling) ContentType() string { + return o.contentType.Get() +} + +// SetContentType sets the value of the contentType property. +func (o *MappingRequestHandling) SetContentType(v string) { + o.contentType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MappingRequestHandling) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Mapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.mapping.SetFromDecode(s) } + } + o.mappingArgumentVariableName.Init(raw) + if val, err := raw.LookupErr("ContentType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.contentType.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MemberChange +// ──────────────────────────────────────────────────────── + +type MemberChange struct { + element.Base + attribute *property.ByNameRef[element.Element] + association *property.ByNameRef[element.Element] + propType *property.Enum[string] + value *property.Primitive[string] + valueModel *property.Part[element.Element] +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *MemberChange) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *MemberChange) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *MemberChange) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *MemberChange) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// Type returns the value of the type property. +func (o *MemberChange) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *MemberChange) SetType(v string) { + o.propType.Set(v) +} + +// Value returns the value of the value property. +func (o *MemberChange) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *MemberChange) SetValue(v string) { + o.value.Set(v) +} + +// ValueModel returns the value of the valueModel property. +func (o *MemberChange) ValueModel() element.Element { + return o.valueModel.Get() +} + +// SetValueModel sets the value of the valueModel property. +func (o *MemberChange) SetValueModel(v element.Element) { + o.valueModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MemberChange) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { o.association.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.value.Init(raw) + if child, err := codec.DecodeChild(raw, "ValueModel"); err == nil { + o.valueModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MeterTagMapping +// ──────────────────────────────────────────────────────── + +type MeterTagMapping struct { + element.Base + key *property.Primitive[string] + value *property.Primitive[string] +} + +// Key returns the value of the key property. +func (o *MeterTagMapping) Key() string { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *MeterTagMapping) SetKey(v string) { + o.key.Set(v) +} + +// Value returns the value of the value property. +func (o *MeterTagMapping) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *MeterTagMapping) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MeterTagMapping) InitFromRaw(raw bson.Raw) { + o.key.Init(raw) + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MicroflowBase +// ──────────────────────────────────────────────────────── + +type MicroflowBase struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + objectCollection *property.Part[element.Element] + flows *property.PartList[element.Element] + returnType *property.Primitive[string] + microflowReturnType *property.Part[element.Element] + markAsUsed *property.Primitive[bool] + returnVariableName *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *MicroflowBase) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MicroflowBase) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MicroflowBase) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MicroflowBase) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *MicroflowBase) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *MicroflowBase) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *MicroflowBase) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *MicroflowBase) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ObjectCollection returns the value of the objectCollection property. +func (o *MicroflowBase) ObjectCollection() element.Element { + return o.objectCollection.Get() +} + +// SetObjectCollection sets the value of the objectCollection property. +func (o *MicroflowBase) SetObjectCollection(v element.Element) { + o.objectCollection.Set(v) +} + +// FlowsItems returns the value of the flows property. +func (o *MicroflowBase) FlowsItems() []element.Element { + return o.flows.Items() +} + +// AddFlows appends a child element to the flows list. +func (o *MicroflowBase) AddFlows(v element.Element) { + o.flows.Append(v) +} + +// RemoveFlows removes the element at the given index from the flows list. +func (o *MicroflowBase) RemoveFlows(index int) { + o.flows.Remove(index) +} + +// ReturnType returns the value of the returnType property. +func (o *MicroflowBase) ReturnType() string { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *MicroflowBase) SetReturnType(v string) { + o.returnType.Set(v) +} + +// MicroflowReturnType returns the value of the microflowReturnType property. +func (o *MicroflowBase) MicroflowReturnType() element.Element { + return o.microflowReturnType.Get() +} + +// SetMicroflowReturnType sets the value of the microflowReturnType property. +func (o *MicroflowBase) SetMicroflowReturnType(v element.Element) { + o.microflowReturnType.Set(v) +} + +// MarkAsUsed returns the value of the markAsUsed property. +func (o *MicroflowBase) MarkAsUsed() bool { + return o.markAsUsed.Get() +} + +// SetMarkAsUsed sets the value of the markAsUsed property. +func (o *MicroflowBase) SetMarkAsUsed(v bool) { + o.markAsUsed.Set(v) +} + +// ReturnVariableName returns the value of the returnVariableName property. +func (o *MicroflowBase) ReturnVariableName() string { + return o.returnVariableName.Get() +} + +// SetReturnVariableName sets the value of the returnVariableName property. +func (o *MicroflowBase) SetReturnVariableName(v string) { + o.returnVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowBase) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ObjectCollection"); err == nil { + o.objectCollection.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Flows"); err == nil { + for _, child := range children { + o.flows.AppendFromDecode(child) + } + } + o.returnType.Init(raw) + if child, err := codec.DecodeChild(raw, "MicroflowReturnType"); err == nil { + o.microflowReturnType.SetFromDecode(child) + } + o.markAsUsed.Init(raw) + o.returnVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ServerSideMicroflow +// ──────────────────────────────────────────────────────── + +type ServerSideMicroflow struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + objectCollection *property.Part[element.Element] + flows *property.PartList[element.Element] + returnType *property.Primitive[string] + microflowReturnType *property.Part[element.Element] + markAsUsed *property.Primitive[bool] + returnVariableName *property.Primitive[string] + applyEntityAccess *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *ServerSideMicroflow) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ServerSideMicroflow) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ServerSideMicroflow) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ServerSideMicroflow) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ServerSideMicroflow) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ServerSideMicroflow) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ServerSideMicroflow) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ServerSideMicroflow) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ObjectCollection returns the value of the objectCollection property. +func (o *ServerSideMicroflow) ObjectCollection() element.Element { + return o.objectCollection.Get() +} + +// SetObjectCollection sets the value of the objectCollection property. +func (o *ServerSideMicroflow) SetObjectCollection(v element.Element) { + o.objectCollection.Set(v) +} + +// FlowsItems returns the value of the flows property. +func (o *ServerSideMicroflow) FlowsItems() []element.Element { + return o.flows.Items() +} + +// AddFlows appends a child element to the flows list. +func (o *ServerSideMicroflow) AddFlows(v element.Element) { + o.flows.Append(v) +} + +// RemoveFlows removes the element at the given index from the flows list. +func (o *ServerSideMicroflow) RemoveFlows(index int) { + o.flows.Remove(index) +} + +// ReturnType returns the value of the returnType property. +func (o *ServerSideMicroflow) ReturnType() string { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *ServerSideMicroflow) SetReturnType(v string) { + o.returnType.Set(v) +} + +// MicroflowReturnType returns the value of the microflowReturnType property. +func (o *ServerSideMicroflow) MicroflowReturnType() element.Element { + return o.microflowReturnType.Get() +} + +// SetMicroflowReturnType sets the value of the microflowReturnType property. +func (o *ServerSideMicroflow) SetMicroflowReturnType(v element.Element) { + o.microflowReturnType.Set(v) +} + +// MarkAsUsed returns the value of the markAsUsed property. +func (o *ServerSideMicroflow) MarkAsUsed() bool { + return o.markAsUsed.Get() +} + +// SetMarkAsUsed sets the value of the markAsUsed property. +func (o *ServerSideMicroflow) SetMarkAsUsed(v bool) { + o.markAsUsed.Set(v) +} + +// ReturnVariableName returns the value of the returnVariableName property. +func (o *ServerSideMicroflow) ReturnVariableName() string { + return o.returnVariableName.Get() +} + +// SetReturnVariableName sets the value of the returnVariableName property. +func (o *ServerSideMicroflow) SetReturnVariableName(v string) { + o.returnVariableName.Set(v) +} + +// ApplyEntityAccess returns the value of the applyEntityAccess property. +func (o *ServerSideMicroflow) ApplyEntityAccess() bool { + return o.applyEntityAccess.Get() +} + +// SetApplyEntityAccess sets the value of the applyEntityAccess property. +func (o *ServerSideMicroflow) SetApplyEntityAccess(v bool) { + o.applyEntityAccess.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ServerSideMicroflow) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ObjectCollection"); err == nil { + o.objectCollection.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Flows"); err == nil { + for _, child := range children { + o.flows.AppendFromDecode(child) + } + } + o.returnType.Init(raw) + if child, err := codec.DecodeChild(raw, "MicroflowReturnType"); err == nil { + o.microflowReturnType.SetFromDecode(child) + } + o.markAsUsed.Init(raw) + o.returnVariableName.Init(raw) + o.applyEntityAccess.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Microflow +// ──────────────────────────────────────────────────────── + +type Microflow struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + objectCollection *property.Part[element.Element] + flows *property.PartList[element.Element] + returnType *property.Primitive[string] + microflowReturnType *property.Part[element.Element] + markAsUsed *property.Primitive[bool] + returnVariableName *property.Primitive[string] + applyEntityAccess *property.Primitive[bool] + allowedModuleRoles *property.ByNameRefList[element.Element] + microflowActionInfo *property.Part[element.Element] + workflowActionInfo *property.Part[element.Element] + allowConcurrentExecution *property.Primitive[bool] + concurrencyErrorMessage *property.Part[element.Element] + concurrencyErrorMicroflow *property.ByNameRef[element.Element] + url *property.Primitive[string] + urlSearchParameters *property.ByNameRefList[element.Element] + stableId *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *Microflow) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Microflow) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Microflow) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Microflow) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Microflow) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Microflow) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Microflow) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Microflow) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ObjectCollection returns the value of the objectCollection property. +func (o *Microflow) ObjectCollection() element.Element { + return o.objectCollection.Get() +} + +// SetObjectCollection sets the value of the objectCollection property. +func (o *Microflow) SetObjectCollection(v element.Element) { + o.objectCollection.Set(v) +} + +// FlowsItems returns the value of the flows property. +func (o *Microflow) FlowsItems() []element.Element { + return o.flows.Items() +} + +// AddFlows appends a child element to the flows list. +func (o *Microflow) AddFlows(v element.Element) { + o.flows.Append(v) +} + +// RemoveFlows removes the element at the given index from the flows list. +func (o *Microflow) RemoveFlows(index int) { + o.flows.Remove(index) +} + +// ReturnType returns the value of the returnType property. +func (o *Microflow) ReturnType() string { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *Microflow) SetReturnType(v string) { + o.returnType.Set(v) +} + +// MicroflowReturnType returns the value of the microflowReturnType property. +func (o *Microflow) MicroflowReturnType() element.Element { + return o.microflowReturnType.Get() +} + +// SetMicroflowReturnType sets the value of the microflowReturnType property. +func (o *Microflow) SetMicroflowReturnType(v element.Element) { + o.microflowReturnType.Set(v) +} + +// MarkAsUsed returns the value of the markAsUsed property. +func (o *Microflow) MarkAsUsed() bool { + return o.markAsUsed.Get() +} + +// SetMarkAsUsed sets the value of the markAsUsed property. +func (o *Microflow) SetMarkAsUsed(v bool) { + o.markAsUsed.Set(v) +} + +// ReturnVariableName returns the value of the returnVariableName property. +func (o *Microflow) ReturnVariableName() string { + return o.returnVariableName.Get() +} + +// SetReturnVariableName sets the value of the returnVariableName property. +func (o *Microflow) SetReturnVariableName(v string) { + o.returnVariableName.Set(v) +} + +// ApplyEntityAccess returns the value of the applyEntityAccess property. +func (o *Microflow) ApplyEntityAccess() bool { + return o.applyEntityAccess.Get() +} + +// SetApplyEntityAccess sets the value of the applyEntityAccess property. +func (o *Microflow) SetApplyEntityAccess(v bool) { + o.applyEntityAccess.Set(v) +} + +// AllowedModuleRolesQualifiedNames returns the value of the allowedModuleRoles property. +func (o *Microflow) AllowedModuleRolesQualifiedNames() []string { + return o.allowedModuleRoles.QualifiedNames() +} + +// SetAllowedModuleRolesQualifiedNames sets the value of the allowedModuleRoles property. +func (o *Microflow) SetAllowedModuleRolesQualifiedNames(v []string) { + o.allowedModuleRoles.SetQualifiedNames(v) +} + +// AddAllowedModuleRoles appends a child element to the allowedModuleRoles list. +func (o *Microflow) AddAllowedModuleRoles(v string) { + o.allowedModuleRoles.Append(v) +} + +// MicroflowActionInfo returns the value of the microflowActionInfo property. +func (o *Microflow) MicroflowActionInfo() element.Element { + return o.microflowActionInfo.Get() +} + +// SetMicroflowActionInfo sets the value of the microflowActionInfo property. +func (o *Microflow) SetMicroflowActionInfo(v element.Element) { + o.microflowActionInfo.Set(v) +} + +// WorkflowActionInfo returns the value of the workflowActionInfo property. +func (o *Microflow) WorkflowActionInfo() element.Element { + return o.workflowActionInfo.Get() +} + +// SetWorkflowActionInfo sets the value of the workflowActionInfo property. +func (o *Microflow) SetWorkflowActionInfo(v element.Element) { + o.workflowActionInfo.Set(v) +} + +// AllowConcurrentExecution returns the value of the allowConcurrentExecution property. +func (o *Microflow) AllowConcurrentExecution() bool { + return o.allowConcurrentExecution.Get() +} + +// SetAllowConcurrentExecution sets the value of the allowConcurrentExecution property. +func (o *Microflow) SetAllowConcurrentExecution(v bool) { + o.allowConcurrentExecution.Set(v) +} + +// ConcurrencyErrorMessage returns the value of the concurrencyErrorMessage property. +func (o *Microflow) ConcurrencyErrorMessage() element.Element { + return o.concurrencyErrorMessage.Get() +} + +// SetConcurrencyErrorMessage sets the value of the concurrencyErrorMessage property. +func (o *Microflow) SetConcurrencyErrorMessage(v element.Element) { + o.concurrencyErrorMessage.Set(v) +} + +// ConcurrencyErrorMicroflowQualifiedName returns the value of the concurrencyErrorMicroflow property. +func (o *Microflow) ConcurrencyErrorMicroflowQualifiedName() string { + return o.concurrencyErrorMicroflow.QualifiedName() +} + +// SetConcurrencyErrorMicroflowQualifiedName sets the value of the concurrencyErrorMicroflow property. +func (o *Microflow) SetConcurrencyErrorMicroflowQualifiedName(v string) { + o.concurrencyErrorMicroflow.SetQualifiedName(v) +} + +// Url returns the value of the url property. +func (o *Microflow) Url() string { + return o.url.Get() +} + +// SetUrl sets the value of the url property. +func (o *Microflow) SetUrl(v string) { + o.url.Set(v) +} + +// UrlSearchParametersQualifiedNames returns the value of the urlSearchParameters property. +func (o *Microflow) UrlSearchParametersQualifiedNames() []string { + return o.urlSearchParameters.QualifiedNames() +} + +// SetUrlSearchParametersQualifiedNames sets the value of the urlSearchParameters property. +func (o *Microflow) SetUrlSearchParametersQualifiedNames(v []string) { + o.urlSearchParameters.SetQualifiedNames(v) +} + +// AddUrlSearchParameters appends a child element to the urlSearchParameters list. +func (o *Microflow) AddUrlSearchParameters(v string) { + o.urlSearchParameters.Append(v) +} + +// StableId returns the value of the stableId property. +func (o *Microflow) StableId() string { + return o.stableId.Get() +} + +// SetStableId sets the value of the stableId property. +func (o *Microflow) SetStableId(v string) { + o.stableId.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Microflow) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ObjectCollection"); err == nil { + o.objectCollection.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Flows"); err == nil { + for _, child := range children { + o.flows.AppendFromDecode(child) + } + } + o.returnType.Init(raw) + if child, err := codec.DecodeChild(raw, "MicroflowReturnType"); err == nil { + o.microflowReturnType.SetFromDecode(child) + } + o.markAsUsed.Init(raw) + o.returnVariableName.Init(raw) + o.applyEntityAccess.Init(raw) + if val, err := raw.LookupErr("AllowedModuleRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.allowedModuleRoles.SetFromDecode(qnames) + } + } + if child, err := codec.DecodeChild(raw, "MicroflowActionInfo"); err == nil { + o.microflowActionInfo.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "WorkflowActionInfo"); err == nil { + o.workflowActionInfo.SetFromDecode(child) + } + o.allowConcurrentExecution.Init(raw) + if child, err := codec.DecodeChild(raw, "ConcurrencyErrorMessage"); err == nil { + o.concurrencyErrorMessage.SetFromDecode(child) + } + if val, err := raw.LookupErr("ConcurrencyErrorMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.concurrencyErrorMicroflow.SetFromDecode(s) } + } + o.url.Init(raw) + if val, err := raw.LookupErr("UrlSearchParameters"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.urlSearchParameters.SetFromDecode(qnames) + } + } + o.stableId.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MicroflowCall +// ──────────────────────────────────────────────────────── + +type MicroflowCall struct { + element.Base + microflow *property.ByNameRef[element.Element] + queueSettings *property.Part[element.Element] + queue *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowCall) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowCall) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// QueueSettings returns the value of the queueSettings property. +func (o *MicroflowCall) QueueSettings() element.Element { + return o.queueSettings.Get() +} + +// SetQueueSettings sets the value of the queueSettings property. +func (o *MicroflowCall) SetQueueSettings(v element.Element) { + o.queueSettings.Set(v) +} + +// QueueQualifiedName returns the value of the queue property. +func (o *MicroflowCall) QueueQualifiedName() string { + return o.queue.QualifiedName() +} + +// SetQueueQualifiedName sets the value of the queue property. +func (o *MicroflowCall) SetQueueQualifiedName(v string) { + o.queue.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *MicroflowCall) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *MicroflowCall) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *MicroflowCall) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowCall) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "QueueSettings"); err == nil { + o.queueSettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Queue"); err == nil { + if s, ok := val.StringValueOK(); ok { o.queue.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowCallAction +// ──────────────────────────────────────────────────────── + +type MicroflowCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + microflowCall *property.Part[element.Element] + useReturnVariable *property.Primitive[bool] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *MicroflowCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *MicroflowCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// MicroflowCall returns the value of the microflowCall property. +func (o *MicroflowCallAction) MicroflowCall() element.Element { + return o.microflowCall.Get() +} + +// SetMicroflowCall sets the value of the microflowCall property. +func (o *MicroflowCallAction) SetMicroflowCall(v element.Element) { + o.microflowCall.Set(v) +} + +// UseReturnVariable returns the value of the useReturnVariable property. +func (o *MicroflowCallAction) UseReturnVariable() bool { + return o.useReturnVariable.Get() +} + +// SetUseReturnVariable sets the value of the useReturnVariable property. +func (o *MicroflowCallAction) SetUseReturnVariable(v bool) { + o.useReturnVariable.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *MicroflowCallAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *MicroflowCallAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "MicroflowCall"); err == nil { + o.microflowCall.SetFromDecode(child) + } + o.useReturnVariable.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MicroflowCallParameterMapping +// ──────────────────────────────────────────────────────── + +type MicroflowCallParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + argument *property.Primitive[string] + argumentModel *property.Part[element.Element] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *MicroflowCallParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *MicroflowCallParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Argument returns the value of the argument property. +func (o *MicroflowCallParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *MicroflowCallParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// ArgumentModel returns the value of the argumentModel property. +func (o *MicroflowCallParameterMapping) ArgumentModel() element.Element { + return o.argumentModel.Get() +} + +// SetArgumentModel sets the value of the argumentModel property. +func (o *MicroflowCallParameterMapping) SetArgumentModel(v element.Element) { + o.argumentModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowCallParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "ArgumentModel"); err == nil { + o.argumentModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowJavaActionParameterValue +// ──────────────────────────────────────────────────────── + +type MicroflowJavaActionParameterValue struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowJavaActionParameterValue) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowJavaActionParameterValue) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowJavaActionParameterValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowObjectCollection +// ──────────────────────────────────────────────────────── + +type MicroflowObjectCollection struct { + element.Base + objects *property.PartList[element.Element] +} + +// ObjectsItems returns the value of the objects property. +func (o *MicroflowObjectCollection) ObjectsItems() []element.Element { + return o.objects.Items() +} + +// AddObjects appends a child element to the objects list. +func (o *MicroflowObjectCollection) AddObjects(v element.Element) { + o.objects.Append(v) +} + +// RemoveObjects removes the element at the given index from the objects list. +func (o *MicroflowObjectCollection) RemoveObjects(index int) { + o.objects.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowObjectCollection) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Objects"); err == nil { + for _, child := range children { + o.objects.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowParameterBase +// ──────────────────────────────────────────────────────── + +type MicroflowParameterBase struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + parameterType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *MicroflowParameterBase) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MicroflowParameterBase) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *MicroflowParameterBase) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *MicroflowParameterBase) SetType(v string) { + o.propType.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *MicroflowParameterBase) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *MicroflowParameterBase) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowParameterBase) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowParameter +// ──────────────────────────────────────────────────────── + +type MicroflowParameter struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + parameterType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *MicroflowParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MicroflowParameter) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *MicroflowParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *MicroflowParameter) SetType(v string) { + o.propType.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *MicroflowParameter) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *MicroflowParameter) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowParameterAttributeUrlSegment +// ──────────────────────────────────────────────────────── + +type MicroflowParameterAttributeUrlSegment struct { + element.Base + microflowParameter *property.ByNameRef[element.Element] + attribute *property.ByNameRef[element.Element] +} + +// MicroflowParameterQualifiedName returns the value of the microflowParameter property. +func (o *MicroflowParameterAttributeUrlSegment) MicroflowParameterQualifiedName() string { + return o.microflowParameter.QualifiedName() +} + +// SetMicroflowParameterQualifiedName sets the value of the microflowParameter property. +func (o *MicroflowParameterAttributeUrlSegment) SetMicroflowParameterQualifiedName(v string) { + o.microflowParameter.SetQualifiedName(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *MicroflowParameterAttributeUrlSegment) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *MicroflowParameterAttributeUrlSegment) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowParameterAttributeUrlSegment) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("MicroflowParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflowParameter.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowParameterObject +// ──────────────────────────────────────────────────────── + +type MicroflowParameterObject struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + name *property.Primitive[string] + propType *property.Primitive[string] + variableType *property.Part[element.Element] + documentation *property.Primitive[string] + hasVariableNameBeenChanged *property.Primitive[bool] + isRequired *property.Primitive[bool] + defaultValue *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *MicroflowParameterObject) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *MicroflowParameterObject) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *MicroflowParameterObject) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *MicroflowParameterObject) SetSize(v string) { + o.size.Set(v) +} + +// Name returns the value of the name property. +func (o *MicroflowParameterObject) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MicroflowParameterObject) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *MicroflowParameterObject) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *MicroflowParameterObject) SetType(v string) { + o.propType.Set(v) +} + +// VariableType returns the value of the variableType property. +func (o *MicroflowParameterObject) VariableType() element.Element { + return o.variableType.Get() +} + +// SetVariableType sets the value of the variableType property. +func (o *MicroflowParameterObject) SetVariableType(v element.Element) { + o.variableType.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MicroflowParameterObject) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MicroflowParameterObject) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// HasVariableNameBeenChanged returns the value of the hasVariableNameBeenChanged property. +func (o *MicroflowParameterObject) HasVariableNameBeenChanged() bool { + return o.hasVariableNameBeenChanged.Get() +} + +// SetHasVariableNameBeenChanged sets the value of the hasVariableNameBeenChanged property. +func (o *MicroflowParameterObject) SetHasVariableNameBeenChanged(v bool) { + o.hasVariableNameBeenChanged.Set(v) +} + +// IsRequired returns the value of the isRequired property. +func (o *MicroflowParameterObject) IsRequired() bool { + return o.isRequired.Get() +} + +// SetIsRequired sets the value of the isRequired property. +func (o *MicroflowParameterObject) SetIsRequired(v bool) { + o.isRequired.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *MicroflowParameterObject) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *MicroflowParameterObject) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowParameterObject) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + o.name.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "VariableType"); err == nil { + o.variableType.SetFromDecode(child) + } + o.documentation.Init(raw) + o.hasVariableNameBeenChanged.Init(raw) + o.isRequired.Init(raw) + o.defaultValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MicroflowParameterValue +// ──────────────────────────────────────────────────────── + +type MicroflowParameterValue struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowParameterValue) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowParameterValue) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowParameterValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowPrimitiveParameterUrlSegment +// ──────────────────────────────────────────────────────── + +type MicroflowPrimitiveParameterUrlSegment struct { + element.Base + microflowParameter *property.ByNameRef[element.Element] +} + +// MicroflowParameterQualifiedName returns the value of the microflowParameter property. +func (o *MicroflowPrimitiveParameterUrlSegment) MicroflowParameterQualifiedName() string { + return o.microflowParameter.QualifiedName() +} + +// SetMicroflowParameterQualifiedName sets the value of the microflowParameter property. +func (o *MicroflowPrimitiveParameterUrlSegment) SetMicroflowParameterQualifiedName(v string) { + o.microflowParameter.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowPrimitiveParameterUrlSegment) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("MicroflowParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflowParameter.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// Nanoflow +// ──────────────────────────────────────────────────────── + +type Nanoflow struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + objectCollection *property.Part[element.Element] + flows *property.PartList[element.Element] + returnType *property.Primitive[string] + microflowReturnType *property.Part[element.Element] + markAsUsed *property.Primitive[bool] + returnVariableName *property.Primitive[string] + allowedModuleRoles *property.ByNameRefList[element.Element] + useListParameterByReference *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *Nanoflow) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Nanoflow) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Nanoflow) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Nanoflow) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Nanoflow) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Nanoflow) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Nanoflow) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Nanoflow) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ObjectCollection returns the value of the objectCollection property. +func (o *Nanoflow) ObjectCollection() element.Element { + return o.objectCollection.Get() +} + +// SetObjectCollection sets the value of the objectCollection property. +func (o *Nanoflow) SetObjectCollection(v element.Element) { + o.objectCollection.Set(v) +} + +// FlowsItems returns the value of the flows property. +func (o *Nanoflow) FlowsItems() []element.Element { + return o.flows.Items() +} + +// AddFlows appends a child element to the flows list. +func (o *Nanoflow) AddFlows(v element.Element) { + o.flows.Append(v) +} + +// RemoveFlows removes the element at the given index from the flows list. +func (o *Nanoflow) RemoveFlows(index int) { + o.flows.Remove(index) +} + +// ReturnType returns the value of the returnType property. +func (o *Nanoflow) ReturnType() string { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *Nanoflow) SetReturnType(v string) { + o.returnType.Set(v) +} + +// MicroflowReturnType returns the value of the microflowReturnType property. +func (o *Nanoflow) MicroflowReturnType() element.Element { + return o.microflowReturnType.Get() +} + +// SetMicroflowReturnType sets the value of the microflowReturnType property. +func (o *Nanoflow) SetMicroflowReturnType(v element.Element) { + o.microflowReturnType.Set(v) +} + +// MarkAsUsed returns the value of the markAsUsed property. +func (o *Nanoflow) MarkAsUsed() bool { + return o.markAsUsed.Get() +} + +// SetMarkAsUsed sets the value of the markAsUsed property. +func (o *Nanoflow) SetMarkAsUsed(v bool) { + o.markAsUsed.Set(v) +} + +// ReturnVariableName returns the value of the returnVariableName property. +func (o *Nanoflow) ReturnVariableName() string { + return o.returnVariableName.Get() +} + +// SetReturnVariableName sets the value of the returnVariableName property. +func (o *Nanoflow) SetReturnVariableName(v string) { + o.returnVariableName.Set(v) +} + +// AllowedModuleRolesQualifiedNames returns the value of the allowedModuleRoles property. +func (o *Nanoflow) AllowedModuleRolesQualifiedNames() []string { + return o.allowedModuleRoles.QualifiedNames() +} + +// SetAllowedModuleRolesQualifiedNames sets the value of the allowedModuleRoles property. +func (o *Nanoflow) SetAllowedModuleRolesQualifiedNames(v []string) { + o.allowedModuleRoles.SetQualifiedNames(v) +} + +// AddAllowedModuleRoles appends a child element to the allowedModuleRoles list. +func (o *Nanoflow) AddAllowedModuleRoles(v string) { + o.allowedModuleRoles.Append(v) +} + +// UseListParameterByReference returns the value of the useListParameterByReference property. +func (o *Nanoflow) UseListParameterByReference() bool { + return o.useListParameterByReference.Get() +} + +// SetUseListParameterByReference sets the value of the useListParameterByReference property. +func (o *Nanoflow) SetUseListParameterByReference(v bool) { + o.useListParameterByReference.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Nanoflow) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ObjectCollection"); err == nil { + o.objectCollection.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Flows"); err == nil { + for _, child := range children { + o.flows.AppendFromDecode(child) + } + } + o.returnType.Init(raw) + if child, err := codec.DecodeChild(raw, "MicroflowReturnType"); err == nil { + o.microflowReturnType.SetFromDecode(child) + } + o.markAsUsed.Init(raw) + o.returnVariableName.Init(raw) + if val, err := raw.LookupErr("AllowedModuleRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.allowedModuleRoles.SetFromDecode(qnames) + } + } + o.useListParameterByReference.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// NanoflowCall +// ──────────────────────────────────────────────────────── + +type NanoflowCall struct { + element.Base + nanoflow *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] +} + +// NanoflowQualifiedName returns the value of the nanoflow property. +func (o *NanoflowCall) NanoflowQualifiedName() string { + return o.nanoflow.QualifiedName() +} + +// SetNanoflowQualifiedName sets the value of the nanoflow property. +func (o *NanoflowCall) SetNanoflowQualifiedName(v string) { + o.nanoflow.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *NanoflowCall) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *NanoflowCall) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *NanoflowCall) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NanoflowCall) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Nanoflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.nanoflow.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// NanoflowCallAction +// ──────────────────────────────────────────────────────── + +type NanoflowCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + nanoflowCall *property.Part[element.Element] + useReturnVariable *property.Primitive[bool] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *NanoflowCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *NanoflowCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// NanoflowCall returns the value of the nanoflowCall property. +func (o *NanoflowCallAction) NanoflowCall() element.Element { + return o.nanoflowCall.Get() +} + +// SetNanoflowCall sets the value of the nanoflowCall property. +func (o *NanoflowCallAction) SetNanoflowCall(v element.Element) { + o.nanoflowCall.Set(v) +} + +// UseReturnVariable returns the value of the useReturnVariable property. +func (o *NanoflowCallAction) UseReturnVariable() bool { + return o.useReturnVariable.Get() +} + +// SetUseReturnVariable sets the value of the useReturnVariable property. +func (o *NanoflowCallAction) SetUseReturnVariable(v bool) { + o.useReturnVariable.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *NanoflowCallAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *NanoflowCallAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NanoflowCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "NanoflowCall"); err == nil { + o.nanoflowCall.SetFromDecode(child) + } + o.useReturnVariable.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// NanoflowCallParameterMapping +// ──────────────────────────────────────────────────────── + +type NanoflowCallParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + argument *property.Primitive[string] + argumentModel *property.Part[element.Element] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *NanoflowCallParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *NanoflowCallParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Argument returns the value of the argument property. +func (o *NanoflowCallParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *NanoflowCallParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// ArgumentModel returns the value of the argumentModel property. +func (o *NanoflowCallParameterMapping) ArgumentModel() element.Element { + return o.argumentModel.Get() +} + +// SetArgumentModel sets the value of the argumentModel property. +func (o *NanoflowCallParameterMapping) SetArgumentModel(v element.Element) { + o.argumentModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NanoflowCallParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "ArgumentModel"); err == nil { + o.argumentModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NanoflowParameter +// ──────────────────────────────────────────────────────── + +type NanoflowParameter struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + parameterType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *NanoflowParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NanoflowParameter) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *NanoflowParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *NanoflowParameter) SetType(v string) { + o.propType.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *NanoflowParameter) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *NanoflowParameter) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NanoflowParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NoCase +// ──────────────────────────────────────────────────────── + +type NoCase struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NoCase) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// NotifyWorkflowAction +// ──────────────────────────────────────────────────────── + +type NotifyWorkflowAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflowVariable *property.Primitive[string] + activity *property.ByNameRef[element.Element] + notifyTarget *property.Part[element.Element] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *NotifyWorkflowAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *NotifyWorkflowAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *NotifyWorkflowAction) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *NotifyWorkflowAction) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// ActivityQualifiedName returns the value of the activity property. +func (o *NotifyWorkflowAction) ActivityQualifiedName() string { + return o.activity.QualifiedName() +} + +// SetActivityQualifiedName sets the value of the activity property. +func (o *NotifyWorkflowAction) SetActivityQualifiedName(v string) { + o.activity.SetQualifiedName(v) +} + +// NotifyTarget returns the value of the notifyTarget property. +func (o *NotifyWorkflowAction) NotifyTarget() element.Element { + return o.notifyTarget.Get() +} + +// SetNotifyTarget sets the value of the notifyTarget property. +func (o *NotifyWorkflowAction) SetNotifyTarget(v element.Element) { + o.notifyTarget.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *NotifyWorkflowAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *NotifyWorkflowAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NotifyWorkflowAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.workflowVariable.Init(raw) + if val, err := raw.LookupErr("Activity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.activity.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "NotifyTarget"); err == nil { + o.notifyTarget.SetFromDecode(child) + } + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OpenUserTaskAction +// ──────────────────────────────────────────────────────── + +type OpenUserTaskAction struct { + element.Base + errorHandlingType *property.Enum[string] + userTaskVariable *property.Primitive[string] + assignOnOpen *property.Primitive[bool] + openWhenAssigned *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *OpenUserTaskAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *OpenUserTaskAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// UserTaskVariable returns the value of the userTaskVariable property. +func (o *OpenUserTaskAction) UserTaskVariable() string { + return o.userTaskVariable.Get() +} + +// SetUserTaskVariable sets the value of the userTaskVariable property. +func (o *OpenUserTaskAction) SetUserTaskVariable(v string) { + o.userTaskVariable.Set(v) +} + +// AssignOnOpen returns the value of the assignOnOpen property. +func (o *OpenUserTaskAction) AssignOnOpen() bool { + return o.assignOnOpen.Get() +} + +// SetAssignOnOpen sets the value of the assignOnOpen property. +func (o *OpenUserTaskAction) SetAssignOnOpen(v bool) { + o.assignOnOpen.Set(v) +} + +// OpenWhenAssigned returns the value of the openWhenAssigned property. +func (o *OpenUserTaskAction) OpenWhenAssigned() bool { + return o.openWhenAssigned.Get() +} + +// SetOpenWhenAssigned sets the value of the openWhenAssigned property. +func (o *OpenUserTaskAction) SetOpenWhenAssigned(v bool) { + o.openWhenAssigned.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OpenUserTaskAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.userTaskVariable.Init(raw) + o.assignOnOpen.Init(raw) + o.openWhenAssigned.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OpenWorkflowAction +// ──────────────────────────────────────────────────────── + +type OpenWorkflowAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflowVariable *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *OpenWorkflowAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *OpenWorkflowAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *OpenWorkflowAction) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *OpenWorkflowAction) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OpenWorkflowAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.workflowVariable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OrthogonalPath +// ──────────────────────────────────────────────────────── + +type OrthogonalPath struct { + element.Base + segmentPositions *property.Primitive[string] +} + +// SegmentPositions returns the value of the segmentPositions property. +func (o *OrthogonalPath) SegmentPositions() string { + return o.segmentPositions.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OrthogonalPath) InitFromRaw(raw bson.Raw) { + o.segmentPositions.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OutputVariable +// ──────────────────────────────────────────────────────── + +type OutputVariable struct { + element.Base + variableName *property.Primitive[string] +} + +// VariableName returns the value of the variableName property. +func (o *OutputVariable) VariableName() string { + return o.variableName.Get() +} + +// SetVariableName sets the value of the variableName property. +func (o *OutputVariable) SetVariableName(v string) { + o.variableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OutputVariable) InitFromRaw(raw bson.Raw) { + o.variableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ParameterIdUrlSegment +// ──────────────────────────────────────────────────────── + +type ParameterIdUrlSegment struct { + element.Base + microflowParameter *property.ByNameRef[element.Element] +} + +// MicroflowParameterQualifiedName returns the value of the microflowParameter property. +func (o *ParameterIdUrlSegment) MicroflowParameterQualifiedName() string { + return o.microflowParameter.QualifiedName() +} + +// SetMicroflowParameterQualifiedName sets the value of the microflowParameter property. +func (o *ParameterIdUrlSegment) SetMicroflowParameterQualifiedName(v string) { + o.microflowParameter.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ParameterIdUrlSegment) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("MicroflowParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflowParameter.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// PauseOperation +// ──────────────────────────────────────────────────────── + +type PauseOperation struct { + element.Base + workflowVariable *property.Primitive[string] +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *PauseOperation) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *PauseOperation) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PauseOperation) InitFromRaw(raw bson.Raw) { + o.workflowVariable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TypedTemplateArgument +// ──────────────────────────────────────────────────────── + +type TypedTemplateArgument struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TypedTemplateArgument) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// PrimitiveTypedTemplateArgument +// ──────────────────────────────────────────────────────── + +type PrimitiveTypedTemplateArgument struct { + element.Base + expression *property.Primitive[string] + propType *property.Enum[string] +} + +// Expression returns the value of the expression property. +func (o *PrimitiveTypedTemplateArgument) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *PrimitiveTypedTemplateArgument) SetExpression(v string) { + o.expression.Set(v) +} + +// Type returns the value of the type property. +func (o *PrimitiveTypedTemplateArgument) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *PrimitiveTypedTemplateArgument) SetType(v string) { + o.propType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PrimitiveTypedTemplateArgument) InitFromRaw(raw bson.Raw) { + o.expression.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ProxyConfiguration +// ──────────────────────────────────────────────────────── + +type ProxyConfiguration struct { + element.Base + usernameExpression *property.Primitive[string] + usernameExpressionModel *property.Part[element.Element] + passwordExpression *property.Primitive[string] + passwordExpressionModel *property.Part[element.Element] + hostExpression *property.Primitive[string] + hostExpressionModel *property.Part[element.Element] + portExpression *property.Primitive[string] + portExpressionModel *property.Part[element.Element] + useConfigurationExpression *property.Primitive[string] + useConfigurationExpressionModel *property.Part[element.Element] +} + +// UsernameExpression returns the value of the usernameExpression property. +func (o *ProxyConfiguration) UsernameExpression() string { + return o.usernameExpression.Get() +} + +// SetUsernameExpression sets the value of the usernameExpression property. +func (o *ProxyConfiguration) SetUsernameExpression(v string) { + o.usernameExpression.Set(v) +} + +// UsernameExpressionModel returns the value of the usernameExpressionModel property. +func (o *ProxyConfiguration) UsernameExpressionModel() element.Element { + return o.usernameExpressionModel.Get() +} + +// SetUsernameExpressionModel sets the value of the usernameExpressionModel property. +func (o *ProxyConfiguration) SetUsernameExpressionModel(v element.Element) { + o.usernameExpressionModel.Set(v) +} + +// PasswordExpression returns the value of the passwordExpression property. +func (o *ProxyConfiguration) PasswordExpression() string { + return o.passwordExpression.Get() +} + +// SetPasswordExpression sets the value of the passwordExpression property. +func (o *ProxyConfiguration) SetPasswordExpression(v string) { + o.passwordExpression.Set(v) +} + +// PasswordExpressionModel returns the value of the passwordExpressionModel property. +func (o *ProxyConfiguration) PasswordExpressionModel() element.Element { + return o.passwordExpressionModel.Get() +} + +// SetPasswordExpressionModel sets the value of the passwordExpressionModel property. +func (o *ProxyConfiguration) SetPasswordExpressionModel(v element.Element) { + o.passwordExpressionModel.Set(v) +} + +// HostExpression returns the value of the hostExpression property. +func (o *ProxyConfiguration) HostExpression() string { + return o.hostExpression.Get() +} + +// SetHostExpression sets the value of the hostExpression property. +func (o *ProxyConfiguration) SetHostExpression(v string) { + o.hostExpression.Set(v) +} + +// HostExpressionModel returns the value of the hostExpressionModel property. +func (o *ProxyConfiguration) HostExpressionModel() element.Element { + return o.hostExpressionModel.Get() +} + +// SetHostExpressionModel sets the value of the hostExpressionModel property. +func (o *ProxyConfiguration) SetHostExpressionModel(v element.Element) { + o.hostExpressionModel.Set(v) +} + +// PortExpression returns the value of the portExpression property. +func (o *ProxyConfiguration) PortExpression() string { + return o.portExpression.Get() +} + +// SetPortExpression sets the value of the portExpression property. +func (o *ProxyConfiguration) SetPortExpression(v string) { + o.portExpression.Set(v) +} + +// PortExpressionModel returns the value of the portExpressionModel property. +func (o *ProxyConfiguration) PortExpressionModel() element.Element { + return o.portExpressionModel.Get() +} + +// SetPortExpressionModel sets the value of the portExpressionModel property. +func (o *ProxyConfiguration) SetPortExpressionModel(v element.Element) { + o.portExpressionModel.Set(v) +} + +// UseConfigurationExpression returns the value of the useConfigurationExpression property. +func (o *ProxyConfiguration) UseConfigurationExpression() string { + return o.useConfigurationExpression.Get() +} + +// SetUseConfigurationExpression sets the value of the useConfigurationExpression property. +func (o *ProxyConfiguration) SetUseConfigurationExpression(v string) { + o.useConfigurationExpression.Set(v) +} + +// UseConfigurationExpressionModel returns the value of the useConfigurationExpressionModel property. +func (o *ProxyConfiguration) UseConfigurationExpressionModel() element.Element { + return o.useConfigurationExpressionModel.Get() +} + +// SetUseConfigurationExpressionModel sets the value of the useConfigurationExpressionModel property. +func (o *ProxyConfiguration) SetUseConfigurationExpressionModel(v element.Element) { + o.useConfigurationExpressionModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ProxyConfiguration) InitFromRaw(raw bson.Raw) { + o.usernameExpression.Init(raw) + if child, err := codec.DecodeChild(raw, "UsernameExpressionModel"); err == nil { + o.usernameExpressionModel.SetFromDecode(child) + } + o.passwordExpression.Init(raw) + if child, err := codec.DecodeChild(raw, "PasswordExpressionModel"); err == nil { + o.passwordExpressionModel.SetFromDecode(child) + } + o.hostExpression.Init(raw) + if child, err := codec.DecodeChild(raw, "HostExpressionModel"); err == nil { + o.hostExpressionModel.SetFromDecode(child) + } + o.portExpression.Init(raw) + if child, err := codec.DecodeChild(raw, "PortExpressionModel"); err == nil { + o.portExpressionModel.SetFromDecode(child) + } + o.useConfigurationExpression.Init(raw) + if child, err := codec.DecodeChild(raw, "UseConfigurationExpressionModel"); err == nil { + o.useConfigurationExpressionModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// PushToClientAction +// ──────────────────────────────────────────────────────── + +type PushToClientAction struct { + element.Base + errorHandlingType *property.Enum[string] + dataVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *PushToClientAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *PushToClientAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// DataVariableName returns the value of the dataVariableName property. +func (o *PushToClientAction) DataVariableName() string { + return o.dataVariableName.Get() +} + +// SetDataVariableName sets the value of the dataVariableName property. +func (o *PushToClientAction) SetDataVariableName(v string) { + o.dataVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PushToClientAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.dataVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// QueryParameterMapping +// ──────────────────────────────────────────────────────── + +type QueryParameterMapping struct { + element.Base + queryParameter *property.ByNameRef[element.Element] + value *property.Primitive[string] + included *property.Enum[string] +} + +// QueryParameterQualifiedName returns the value of the queryParameter property. +func (o *QueryParameterMapping) QueryParameterQualifiedName() string { + return o.queryParameter.QualifiedName() +} + +// SetQueryParameterQualifiedName sets the value of the queryParameter property. +func (o *QueryParameterMapping) SetQueryParameterQualifiedName(v string) { + o.queryParameter.SetQualifiedName(v) +} + +// Value returns the value of the value property. +func (o *QueryParameterMapping) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *QueryParameterMapping) SetValue(v string) { + o.value.Set(v) +} + +// Included returns the value of the included property. +func (o *QueryParameterMapping) Included() string { + return o.included.Get() +} + +// SetIncluded sets the value of the included property. +func (o *QueryParameterMapping) SetIncluded(v string) { + o.included.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueryParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("QueryParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.queryParameter.SetFromDecode(s) } + } + o.value.Init(raw) + if val, err := raw.LookupErr("Included"); err == nil { + if s, ok := val.StringValueOK(); ok { o.included.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// RestCallAction +// ──────────────────────────────────────────────────────── + +type RestCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + httpConfiguration *property.Part[element.Element] + requestHandling *property.Part[element.Element] + requestHandlingType *property.Enum[string] + resultHandling *property.Part[element.Element] + resultHandlingType *property.Enum[string] + errorResultHandlingType *property.Enum[string] + useRequestTimeOut *property.Primitive[bool] + timeOut *property.Primitive[int32] + timeOutModel *property.Part[element.Element] + timeOutExpression *property.Primitive[string] + requestProxyType *property.Enum[string] + proxyConfiguration *property.Part[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *RestCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *RestCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// HttpConfiguration returns the value of the httpConfiguration property. +func (o *RestCallAction) HttpConfiguration() element.Element { + return o.httpConfiguration.Get() +} + +// SetHttpConfiguration sets the value of the httpConfiguration property. +func (o *RestCallAction) SetHttpConfiguration(v element.Element) { + o.httpConfiguration.Set(v) +} + +// RequestHandling returns the value of the requestHandling property. +func (o *RestCallAction) RequestHandling() element.Element { + return o.requestHandling.Get() +} + +// SetRequestHandling sets the value of the requestHandling property. +func (o *RestCallAction) SetRequestHandling(v element.Element) { + o.requestHandling.Set(v) +} + +// RequestHandlingType returns the value of the requestHandlingType property. +func (o *RestCallAction) RequestHandlingType() string { + return o.requestHandlingType.Get() +} + +// SetRequestHandlingType sets the value of the requestHandlingType property. +func (o *RestCallAction) SetRequestHandlingType(v string) { + o.requestHandlingType.Set(v) +} + +// ResultHandling returns the value of the resultHandling property. +func (o *RestCallAction) ResultHandling() element.Element { + return o.resultHandling.Get() +} + +// SetResultHandling sets the value of the resultHandling property. +func (o *RestCallAction) SetResultHandling(v element.Element) { + o.resultHandling.Set(v) +} + +// ResultHandlingType returns the value of the resultHandlingType property. +func (o *RestCallAction) ResultHandlingType() string { + return o.resultHandlingType.Get() +} + +// SetResultHandlingType sets the value of the resultHandlingType property. +func (o *RestCallAction) SetResultHandlingType(v string) { + o.resultHandlingType.Set(v) +} + +// ErrorResultHandlingType returns the value of the errorResultHandlingType property. +func (o *RestCallAction) ErrorResultHandlingType() string { + return o.errorResultHandlingType.Get() +} + +// SetErrorResultHandlingType sets the value of the errorResultHandlingType property. +func (o *RestCallAction) SetErrorResultHandlingType(v string) { + o.errorResultHandlingType.Set(v) +} + +// UseRequestTimeOut returns the value of the useRequestTimeOut property. +func (o *RestCallAction) UseRequestTimeOut() bool { + return o.useRequestTimeOut.Get() +} + +// SetUseRequestTimeOut sets the value of the useRequestTimeOut property. +func (o *RestCallAction) SetUseRequestTimeOut(v bool) { + o.useRequestTimeOut.Set(v) +} + +// TimeOut returns the value of the timeOut property. +func (o *RestCallAction) TimeOut() int32 { + return o.timeOut.Get() +} + +// SetTimeOut sets the value of the timeOut property. +func (o *RestCallAction) SetTimeOut(v int32) { + o.timeOut.Set(v) +} + +// TimeOutModel returns the value of the timeOutModel property. +func (o *RestCallAction) TimeOutModel() element.Element { + return o.timeOutModel.Get() +} + +// SetTimeOutModel sets the value of the timeOutModel property. +func (o *RestCallAction) SetTimeOutModel(v element.Element) { + o.timeOutModel.Set(v) +} + +// TimeOutExpression returns the value of the timeOutExpression property. +func (o *RestCallAction) TimeOutExpression() string { + return o.timeOutExpression.Get() +} + +// SetTimeOutExpression sets the value of the timeOutExpression property. +func (o *RestCallAction) SetTimeOutExpression(v string) { + o.timeOutExpression.Set(v) +} + +// RequestProxyType returns the value of the requestProxyType property. +func (o *RestCallAction) RequestProxyType() string { + return o.requestProxyType.Get() +} + +// SetRequestProxyType sets the value of the requestProxyType property. +func (o *RestCallAction) SetRequestProxyType(v string) { + o.requestProxyType.Set(v) +} + +// ProxyConfiguration returns the value of the proxyConfiguration property. +func (o *RestCallAction) ProxyConfiguration() element.Element { + return o.proxyConfiguration.Get() +} + +// SetProxyConfiguration sets the value of the proxyConfiguration property. +func (o *RestCallAction) SetProxyConfiguration(v element.Element) { + o.proxyConfiguration.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "HttpConfiguration"); err == nil { + o.httpConfiguration.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "RequestHandling"); err == nil { + o.requestHandling.SetFromDecode(child) + } + if val, err := raw.LookupErr("RequestHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.requestHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ResultHandling"); err == nil { + o.resultHandling.SetFromDecode(child) + } + if val, err := raw.LookupErr("ResultHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.resultHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ErrorResultHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorResultHandlingType.SetFromDecode(s) } + } + o.useRequestTimeOut.Init(raw) + o.timeOut.Init(raw) + if child, err := codec.DecodeChild(raw, "TimeOutModel"); err == nil { + o.timeOutModel.SetFromDecode(child) + } + o.timeOutExpression.Init(raw) + if val, err := raw.LookupErr("RequestProxyType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.requestProxyType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ProxyConfiguration"); err == nil { + o.proxyConfiguration.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// RestOperationCallAction +// ──────────────────────────────────────────────────────── + +type RestOperationCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + operation *property.ByNameRef[element.Element] + baseUrlParameterMapping *property.Part[element.Element] + bodyVariable *property.Part[element.Element] + parameterMappings *property.PartList[element.Element] + queryParameterMappings *property.PartList[element.Element] + outputVariable *property.Part[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *RestOperationCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *RestOperationCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// OperationQualifiedName returns the value of the operation property. +func (o *RestOperationCallAction) OperationQualifiedName() string { + return o.operation.QualifiedName() +} + +// SetOperationQualifiedName sets the value of the operation property. +func (o *RestOperationCallAction) SetOperationQualifiedName(v string) { + o.operation.SetQualifiedName(v) +} + +// BaseUrlParameterMapping returns the value of the baseUrlParameterMapping property. +func (o *RestOperationCallAction) BaseUrlParameterMapping() element.Element { + return o.baseUrlParameterMapping.Get() +} + +// SetBaseUrlParameterMapping sets the value of the baseUrlParameterMapping property. +func (o *RestOperationCallAction) SetBaseUrlParameterMapping(v element.Element) { + o.baseUrlParameterMapping.Set(v) +} + +// BodyVariable returns the value of the bodyVariable property. +func (o *RestOperationCallAction) BodyVariable() element.Element { + return o.bodyVariable.Get() +} + +// SetBodyVariable sets the value of the bodyVariable property. +func (o *RestOperationCallAction) SetBodyVariable(v element.Element) { + o.bodyVariable.Set(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *RestOperationCallAction) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *RestOperationCallAction) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *RestOperationCallAction) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// QueryParameterMappingsItems returns the value of the queryParameterMappings property. +func (o *RestOperationCallAction) QueryParameterMappingsItems() []element.Element { + return o.queryParameterMappings.Items() +} + +// AddQueryParameterMappings appends a child element to the queryParameterMappings list. +func (o *RestOperationCallAction) AddQueryParameterMappings(v element.Element) { + o.queryParameterMappings.Append(v) +} + +// RemoveQueryParameterMappings removes the element at the given index from the queryParameterMappings list. +func (o *RestOperationCallAction) RemoveQueryParameterMappings(index int) { + o.queryParameterMappings.Remove(index) +} + +// OutputVariable returns the value of the outputVariable property. +func (o *RestOperationCallAction) OutputVariable() element.Element { + return o.outputVariable.Get() +} + +// SetOutputVariable sets the value of the outputVariable property. +func (o *RestOperationCallAction) SetOutputVariable(v element.Element) { + o.outputVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestOperationCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Operation"); err == nil { + if s, ok := val.StringValueOK(); ok { o.operation.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "BaseUrlParameterMapping"); err == nil { + o.baseUrlParameterMapping.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "BodyVariable"); err == nil { + o.bodyVariable.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "QueryParameterMappings"); err == nil { + for _, child := range children { + o.queryParameterMappings.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "OutputVariable"); err == nil { + o.outputVariable.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// RestOperationParameterMapping +// ──────────────────────────────────────────────────────── + +type RestOperationParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + value *property.Primitive[string] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *RestOperationParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *RestOperationParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Value returns the value of the value property. +func (o *RestOperationParameterMapping) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *RestOperationParameterMapping) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestOperationParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RestParameterMapping +// ──────────────────────────────────────────────────────── + +type RestParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + value *property.Primitive[string] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *RestParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *RestParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Value returns the value of the value property. +func (o *RestParameterMapping) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *RestParameterMapping) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RestartOperation +// ──────────────────────────────────────────────────────── + +type RestartOperation struct { + element.Base + workflowVariable *property.Primitive[string] +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *RestartOperation) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *RestartOperation) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestartOperation) InitFromRaw(raw bson.Raw) { + o.workflowVariable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ResultHandling +// ──────────────────────────────────────────────────────── + +type ResultHandling struct { + element.Base + importMappingCall *property.Part[element.Element] + storeInVariable *property.Primitive[bool] + outputVariableName *property.Primitive[string] + variableDataType *property.Primitive[string] + variableType *property.Part[element.Element] +} + +// ImportMappingCall returns the value of the importMappingCall property. +func (o *ResultHandling) ImportMappingCall() element.Element { + return o.importMappingCall.Get() +} + +// SetImportMappingCall sets the value of the importMappingCall property. +func (o *ResultHandling) SetImportMappingCall(v element.Element) { + o.importMappingCall.Set(v) +} + +// StoreInVariable returns the value of the storeInVariable property. +func (o *ResultHandling) StoreInVariable() bool { + return o.storeInVariable.Get() +} + +// SetStoreInVariable sets the value of the storeInVariable property. +func (o *ResultHandling) SetStoreInVariable(v bool) { + o.storeInVariable.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *ResultHandling) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *ResultHandling) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// VariableDataType returns the value of the variableDataType property. +func (o *ResultHandling) VariableDataType() string { + return o.variableDataType.Get() +} + +// SetVariableDataType sets the value of the variableDataType property. +func (o *ResultHandling) SetVariableDataType(v string) { + o.variableDataType.Set(v) +} + +// VariableType returns the value of the variableType property. +func (o *ResultHandling) VariableType() element.Element { + return o.variableType.Get() +} + +// SetVariableType sets the value of the variableType property. +func (o *ResultHandling) SetVariableType(v element.Element) { + o.variableType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ResultHandling) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "ImportMappingCall"); err == nil { + o.importMappingCall.SetFromDecode(child) + } + o.storeInVariable.Init(raw) + o.outputVariableName.Init(raw) + o.variableDataType.Init(raw) + if child, err := codec.DecodeChild(raw, "VariableType"); err == nil { + o.variableType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ResumeOperation +// ──────────────────────────────────────────────────────── + +type ResumeOperation struct { + element.Base + workflowVariable *property.Primitive[string] +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *ResumeOperation) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *ResumeOperation) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ResumeOperation) InitFromRaw(raw bson.Raw) { + o.workflowVariable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RetrieveAction +// ──────────────────────────────────────────────────────── + +type RetrieveAction struct { + element.Base + errorHandlingType *property.Enum[string] + retrieveSource *property.Part[element.Element] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *RetrieveAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *RetrieveAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// RetrieveSource returns the value of the retrieveSource property. +func (o *RetrieveAction) RetrieveSource() element.Element { + return o.retrieveSource.Get() +} + +// SetRetrieveSource sets the value of the retrieveSource property. +func (o *RetrieveAction) SetRetrieveSource(v element.Element) { + o.retrieveSource.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *RetrieveAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *RetrieveAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RetrieveAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "RetrieveSource"); err == nil { + o.retrieveSource.SetFromDecode(child) + } + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RetryOperation +// ──────────────────────────────────────────────────────── + +type RetryOperation struct { + element.Base + workflowVariable *property.Primitive[string] +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *RetryOperation) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *RetryOperation) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RetryOperation) InitFromRaw(raw bson.Raw) { + o.workflowVariable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RollbackAction +// ──────────────────────────────────────────────────────── + +type RollbackAction struct { + element.Base + errorHandlingType *property.Enum[string] + rollbackVariableName *property.Primitive[string] + refreshInClient *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *RollbackAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *RollbackAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// RollbackVariableName returns the value of the rollbackVariableName property. +func (o *RollbackAction) RollbackVariableName() string { + return o.rollbackVariableName.Get() +} + +// SetRollbackVariableName sets the value of the rollbackVariableName property. +func (o *RollbackAction) SetRollbackVariableName(v string) { + o.rollbackVariableName.Set(v) +} + +// RefreshInClient returns the value of the refreshInClient property. +func (o *RollbackAction) RefreshInClient() bool { + return o.refreshInClient.Get() +} + +// SetRefreshInClient sets the value of the refreshInClient property. +func (o *RollbackAction) SetRefreshInClient(v bool) { + o.refreshInClient.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RollbackAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.rollbackVariableName.Init(raw) + o.refreshInClient.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Rule +// ──────────────────────────────────────────────────────── + +type Rule struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + objectCollection *property.Part[element.Element] + flows *property.PartList[element.Element] + returnType *property.Primitive[string] + microflowReturnType *property.Part[element.Element] + markAsUsed *property.Primitive[bool] + returnVariableName *property.Primitive[string] + applyEntityAccess *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *Rule) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Rule) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Rule) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Rule) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Rule) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Rule) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Rule) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Rule) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ObjectCollection returns the value of the objectCollection property. +func (o *Rule) ObjectCollection() element.Element { + return o.objectCollection.Get() +} + +// SetObjectCollection sets the value of the objectCollection property. +func (o *Rule) SetObjectCollection(v element.Element) { + o.objectCollection.Set(v) +} + +// FlowsItems returns the value of the flows property. +func (o *Rule) FlowsItems() []element.Element { + return o.flows.Items() +} + +// AddFlows appends a child element to the flows list. +func (o *Rule) AddFlows(v element.Element) { + o.flows.Append(v) +} + +// RemoveFlows removes the element at the given index from the flows list. +func (o *Rule) RemoveFlows(index int) { + o.flows.Remove(index) +} + +// ReturnType returns the value of the returnType property. +func (o *Rule) ReturnType() string { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *Rule) SetReturnType(v string) { + o.returnType.Set(v) +} + +// MicroflowReturnType returns the value of the microflowReturnType property. +func (o *Rule) MicroflowReturnType() element.Element { + return o.microflowReturnType.Get() +} + +// SetMicroflowReturnType sets the value of the microflowReturnType property. +func (o *Rule) SetMicroflowReturnType(v element.Element) { + o.microflowReturnType.Set(v) +} + +// MarkAsUsed returns the value of the markAsUsed property. +func (o *Rule) MarkAsUsed() bool { + return o.markAsUsed.Get() +} + +// SetMarkAsUsed sets the value of the markAsUsed property. +func (o *Rule) SetMarkAsUsed(v bool) { + o.markAsUsed.Set(v) +} + +// ReturnVariableName returns the value of the returnVariableName property. +func (o *Rule) ReturnVariableName() string { + return o.returnVariableName.Get() +} + +// SetReturnVariableName sets the value of the returnVariableName property. +func (o *Rule) SetReturnVariableName(v string) { + o.returnVariableName.Set(v) +} + +// ApplyEntityAccess returns the value of the applyEntityAccess property. +func (o *Rule) ApplyEntityAccess() bool { + return o.applyEntityAccess.Get() +} + +// SetApplyEntityAccess sets the value of the applyEntityAccess property. +func (o *Rule) SetApplyEntityAccess(v bool) { + o.applyEntityAccess.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Rule) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ObjectCollection"); err == nil { + o.objectCollection.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Flows"); err == nil { + for _, child := range children { + o.flows.AppendFromDecode(child) + } + } + o.returnType.Init(raw) + if child, err := codec.DecodeChild(raw, "MicroflowReturnType"); err == nil { + o.microflowReturnType.SetFromDecode(child) + } + o.markAsUsed.Init(raw) + o.returnVariableName.Init(raw) + o.applyEntityAccess.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RuleCall +// ──────────────────────────────────────────────────────── + +type RuleCall struct { + element.Base + rule *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] +} + +// RuleQualifiedName returns the value of the rule property. +func (o *RuleCall) RuleQualifiedName() string { + return o.rule.QualifiedName() +} + +// SetRuleQualifiedName sets the value of the rule property. +func (o *RuleCall) SetRuleQualifiedName(v string) { + o.rule.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *RuleCall) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *RuleCall) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *RuleCall) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RuleCall) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Rule"); err == nil { + if s, ok := val.StringValueOK(); ok { o.rule.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// RuleCallParameterMapping +// ──────────────────────────────────────────────────────── + +type RuleCallParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + argument *property.Primitive[string] + argumentModel *property.Part[element.Element] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *RuleCallParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *RuleCallParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Argument returns the value of the argument property. +func (o *RuleCallParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *RuleCallParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// ArgumentModel returns the value of the argumentModel property. +func (o *RuleCallParameterMapping) ArgumentModel() element.Element { + return o.argumentModel.Get() +} + +// SetArgumentModel sets the value of the argumentModel property. +func (o *RuleCallParameterMapping) SetArgumentModel(v element.Element) { + o.argumentModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RuleCallParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "ArgumentModel"); err == nil { + o.argumentModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// RuleParameter +// ──────────────────────────────────────────────────────── + +type RuleParameter struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + parameterType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *RuleParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RuleParameter) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *RuleParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *RuleParameter) SetType(v string) { + o.propType.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *RuleParameter) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *RuleParameter) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RuleParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// RuleSplitCondition +// ──────────────────────────────────────────────────────── + +type RuleSplitCondition struct { + element.Base + ruleCall *property.Part[element.Element] +} + +// RuleCall returns the value of the ruleCall property. +func (o *RuleSplitCondition) RuleCall() element.Element { + return o.ruleCall.Get() +} + +// SetRuleCall sets the value of the ruleCall property. +func (o *RuleSplitCondition) SetRuleCall(v element.Element) { + o.ruleCall.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RuleSplitCondition) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "RuleCall"); err == nil { + o.ruleCall.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// SendEmailAction +// ──────────────────────────────────────────────────────── + +type SendEmailAction struct { + element.Base + errorHandlingType *property.Enum[string] + emailAuthenticationConfig *property.Part[element.Element] + emailConnectionConfig *property.Part[element.Element] + emailMessage *property.Part[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *SendEmailAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *SendEmailAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// EmailAuthenticationConfig returns the value of the emailAuthenticationConfig property. +func (o *SendEmailAction) EmailAuthenticationConfig() element.Element { + return o.emailAuthenticationConfig.Get() +} + +// SetEmailAuthenticationConfig sets the value of the emailAuthenticationConfig property. +func (o *SendEmailAction) SetEmailAuthenticationConfig(v element.Element) { + o.emailAuthenticationConfig.Set(v) +} + +// EmailConnectionConfig returns the value of the emailConnectionConfig property. +func (o *SendEmailAction) EmailConnectionConfig() element.Element { + return o.emailConnectionConfig.Get() +} + +// SetEmailConnectionConfig sets the value of the emailConnectionConfig property. +func (o *SendEmailAction) SetEmailConnectionConfig(v element.Element) { + o.emailConnectionConfig.Set(v) +} + +// EmailMessage returns the value of the emailMessage property. +func (o *SendEmailAction) EmailMessage() element.Element { + return o.emailMessage.Get() +} + +// SetEmailMessage sets the value of the emailMessage property. +func (o *SendEmailAction) SetEmailMessage(v element.Element) { + o.emailMessage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SendEmailAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "EmailAuthenticationConfig"); err == nil { + o.emailAuthenticationConfig.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "EmailConnectionConfig"); err == nil { + o.emailConnectionConfig.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "EmailMessage"); err == nil { + o.emailMessage.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// SendExternalObject +// ──────────────────────────────────────────────────────── + +type SendExternalObject struct { + element.Base + errorHandlingType *property.Enum[string] + variableNameToBeSent *property.Primitive[string] + refreshInClient *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *SendExternalObject) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *SendExternalObject) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// VariableNameToBeSent returns the value of the variableNameToBeSent property. +func (o *SendExternalObject) VariableNameToBeSent() string { + return o.variableNameToBeSent.Get() +} + +// SetVariableNameToBeSent sets the value of the variableNameToBeSent property. +func (o *SendExternalObject) SetVariableNameToBeSent(v string) { + o.variableNameToBeSent.Set(v) +} + +// RefreshInClient returns the value of the refreshInClient property. +func (o *SendExternalObject) RefreshInClient() bool { + return o.refreshInClient.Get() +} + +// SetRefreshInClient sets the value of the refreshInClient property. +func (o *SendExternalObject) SetRefreshInClient(v bool) { + o.refreshInClient.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SendExternalObject) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.variableNameToBeSent.Init(raw) + o.refreshInClient.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SequenceFlow +// ──────────────────────────────────────────────────────── + +type SequenceFlow struct { + element.Base + origin *property.ByIdRef[element.Element] + destination *property.ByIdRef[element.Element] + originConnectionIndex *property.Primitive[int32] + destinationConnectionIndex *property.Primitive[int32] + originBezierVector *property.Primitive[string] + destinationBezierVector *property.Primitive[string] + lineType *property.Enum[string] + line *property.Part[element.Element] + caseValue *property.Part[element.Element] + caseValues *property.PartList[element.Element] + isErrorHandler *property.Primitive[bool] +} + +// OriginRefID returns the value of the origin property. +func (o *SequenceFlow) OriginRefID() element.ID { + return o.origin.RefID() +} + +// SetOriginID sets the value of the origin property. +func (o *SequenceFlow) SetOriginID(v element.ID) { + o.origin.SetID(v) +} + +// DestinationRefID returns the value of the destination property. +func (o *SequenceFlow) DestinationRefID() element.ID { + return o.destination.RefID() +} + +// SetDestinationID sets the value of the destination property. +func (o *SequenceFlow) SetDestinationID(v element.ID) { + o.destination.SetID(v) +} + +// OriginConnectionIndex returns the value of the originConnectionIndex property. +func (o *SequenceFlow) OriginConnectionIndex() int32 { + return o.originConnectionIndex.Get() +} + +// SetOriginConnectionIndex sets the value of the originConnectionIndex property. +func (o *SequenceFlow) SetOriginConnectionIndex(v int32) { + o.originConnectionIndex.Set(v) +} + +// DestinationConnectionIndex returns the value of the destinationConnectionIndex property. +func (o *SequenceFlow) DestinationConnectionIndex() int32 { + return o.destinationConnectionIndex.Get() +} + +// SetDestinationConnectionIndex sets the value of the destinationConnectionIndex property. +func (o *SequenceFlow) SetDestinationConnectionIndex(v int32) { + o.destinationConnectionIndex.Set(v) +} + +// OriginBezierVector returns the value of the originBezierVector property. +func (o *SequenceFlow) OriginBezierVector() string { + return o.originBezierVector.Get() +} + +// SetOriginBezierVector sets the value of the originBezierVector property. +func (o *SequenceFlow) SetOriginBezierVector(v string) { + o.originBezierVector.Set(v) +} + +// DestinationBezierVector returns the value of the destinationBezierVector property. +func (o *SequenceFlow) DestinationBezierVector() string { + return o.destinationBezierVector.Get() +} + +// SetDestinationBezierVector sets the value of the destinationBezierVector property. +func (o *SequenceFlow) SetDestinationBezierVector(v string) { + o.destinationBezierVector.Set(v) +} + +// LineType returns the value of the lineType property. +func (o *SequenceFlow) LineType() string { + return o.lineType.Get() +} + +// SetLineType sets the value of the lineType property. +func (o *SequenceFlow) SetLineType(v string) { + o.lineType.Set(v) +} + +// Line returns the value of the line property. +func (o *SequenceFlow) Line() element.Element { + return o.line.Get() +} + +// SetLine sets the value of the line property. +func (o *SequenceFlow) SetLine(v element.Element) { + o.line.Set(v) +} + +// CaseValue returns the value of the caseValue property. +func (o *SequenceFlow) CaseValue() element.Element { + return o.caseValue.Get() +} + +// SetCaseValue sets the value of the caseValue property. +func (o *SequenceFlow) SetCaseValue(v element.Element) { + o.caseValue.Set(v) +} + +// CaseValuesItems returns the value of the caseValues property. +func (o *SequenceFlow) CaseValuesItems() []element.Element { + return o.caseValues.Items() +} + +// AddCaseValues appends a child element to the caseValues list. +func (o *SequenceFlow) AddCaseValues(v element.Element) { + o.caseValues.Append(v) +} + +// RemoveCaseValues removes the element at the given index from the caseValues list. +func (o *SequenceFlow) RemoveCaseValues(index int) { + o.caseValues.Remove(index) +} + +// IsErrorHandler returns the value of the isErrorHandler property. +func (o *SequenceFlow) IsErrorHandler() bool { + return o.isErrorHandler.Get() +} + +// SetIsErrorHandler sets the value of the isErrorHandler property. +func (o *SequenceFlow) SetIsErrorHandler(v bool) { + o.isErrorHandler.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SequenceFlow) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("OriginPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.origin.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.origin.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + if val, err := raw.LookupErr("DestinationPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.destination.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.destination.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.originConnectionIndex.Init(raw) + o.destinationConnectionIndex.Init(raw) + o.originBezierVector.Init(raw) + o.destinationBezierVector.Init(raw) + if val, err := raw.LookupErr("LineType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.lineType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Line"); err == nil { + o.line.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "CaseValue"); err == nil { + o.caseValue.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "CaseValues"); err == nil { + for _, child := range children { + o.caseValues.AppendFromDecode(child) + } + } + o.isErrorHandler.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SetTaskOutcomeAction +// ──────────────────────────────────────────────────────── + +type SetTaskOutcomeAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflowTaskVariable *property.Primitive[string] + outcome *property.ByNameRef[element.Element] + outcomeValue *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *SetTaskOutcomeAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *SetTaskOutcomeAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowTaskVariable returns the value of the workflowTaskVariable property. +func (o *SetTaskOutcomeAction) WorkflowTaskVariable() string { + return o.workflowTaskVariable.Get() +} + +// SetWorkflowTaskVariable sets the value of the workflowTaskVariable property. +func (o *SetTaskOutcomeAction) SetWorkflowTaskVariable(v string) { + o.workflowTaskVariable.Set(v) +} + +// OutcomeQualifiedName returns the value of the outcome property. +func (o *SetTaskOutcomeAction) OutcomeQualifiedName() string { + return o.outcome.QualifiedName() +} + +// SetOutcomeQualifiedName sets the value of the outcome property. +func (o *SetTaskOutcomeAction) SetOutcomeQualifiedName(v string) { + o.outcome.SetQualifiedName(v) +} + +// OutcomeValue returns the value of the outcomeValue property. +func (o *SetTaskOutcomeAction) OutcomeValue() string { + return o.outcomeValue.Get() +} + +// SetOutcomeValue sets the value of the outcomeValue property. +func (o *SetTaskOutcomeAction) SetOutcomeValue(v string) { + o.outcomeValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SetTaskOutcomeAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + o.workflowTaskVariable.Init(raw) + if val, err := raw.LookupErr("Outcome"); err == nil { + if s, ok := val.StringValueOK(); ok { o.outcome.SetFromDecode(s) } + } + o.outcomeValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ShowHomePageAction +// ──────────────────────────────────────────────────────── + +type ShowHomePageAction struct { + element.Base + errorHandlingType *property.Enum[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ShowHomePageAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ShowHomePageAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ShowHomePageAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ShowMessageAction +// ──────────────────────────────────────────────────────── + +type ShowMessageAction struct { + element.Base + errorHandlingType *property.Enum[string] + template *property.Part[element.Element] + propType *property.Enum[string] + blocking *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ShowMessageAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ShowMessageAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Template returns the value of the template property. +func (o *ShowMessageAction) Template() element.Element { + return o.template.Get() +} + +// SetTemplate sets the value of the template property. +func (o *ShowMessageAction) SetTemplate(v element.Element) { + o.template.Set(v) +} + +// Type returns the value of the type property. +func (o *ShowMessageAction) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *ShowMessageAction) SetType(v string) { + o.propType.Set(v) +} + +// Blocking returns the value of the blocking property. +func (o *ShowMessageAction) Blocking() bool { + return o.blocking.Get() +} + +// SetBlocking sets the value of the blocking property. +func (o *ShowMessageAction) SetBlocking(v bool) { + o.blocking.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ShowMessageAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Template"); err == nil { + o.template.SetFromDecode(child) + } + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.blocking.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ShowPageAction +// ──────────────────────────────────────────────────────── + +type ShowPageAction struct { + element.Base + errorHandlingType *property.Enum[string] + pageSettings *property.Part[element.Element] + passedObjectVariableName *property.Primitive[string] + numberOfPagesToClose *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ShowPageAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ShowPageAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// PageSettings returns the value of the pageSettings property. +func (o *ShowPageAction) PageSettings() element.Element { + return o.pageSettings.Get() +} + +// SetPageSettings sets the value of the pageSettings property. +func (o *ShowPageAction) SetPageSettings(v element.Element) { + o.pageSettings.Set(v) +} + +// PassedObjectVariableName returns the value of the passedObjectVariableName property. +func (o *ShowPageAction) PassedObjectVariableName() string { + return o.passedObjectVariableName.Get() +} + +// SetPassedObjectVariableName sets the value of the passedObjectVariableName property. +func (o *ShowPageAction) SetPassedObjectVariableName(v string) { + o.passedObjectVariableName.Set(v) +} + +// NumberOfPagesToClose returns the value of the numberOfPagesToClose property. +func (o *ShowPageAction) NumberOfPagesToClose() string { + return o.numberOfPagesToClose.Get() +} + +// SetNumberOfPagesToClose sets the value of the numberOfPagesToClose property. +func (o *ShowPageAction) SetNumberOfPagesToClose(v string) { + o.numberOfPagesToClose.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ShowPageAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "PageSettings"); err == nil { + o.pageSettings.SetFromDecode(child) + } + o.passedObjectVariableName.Init(raw) + o.numberOfPagesToClose.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SimpleRequestHandling +// ──────────────────────────────────────────────────────── + +type SimpleRequestHandling struct { + element.Base + parameterMappings *property.PartList[element.Element] + nullValueOption *property.Enum[string] +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *SimpleRequestHandling) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *SimpleRequestHandling) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *SimpleRequestHandling) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// NullValueOption returns the value of the nullValueOption property. +func (o *SimpleRequestHandling) NullValueOption() string { + return o.nullValueOption.Get() +} + +// SetNullValueOption sets the value of the nullValueOption property. +func (o *SimpleRequestHandling) SetNullValueOption(v string) { + o.nullValueOption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SimpleRequestHandling) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("NullValueOption"); err == nil { + if s, ok := val.StringValueOK(); ok { o.nullValueOption.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// Sort +// ──────────────────────────────────────────────────────── + +type Sort struct { + element.Base + listVariableName *property.Primitive[string] + sortItemList *property.Part[element.Element] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *Sort) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *Sort) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// SortItemList returns the value of the sortItemList property. +func (o *Sort) SortItemList() element.Element { + return o.sortItemList.Get() +} + +// SetSortItemList sets the value of the sortItemList property. +func (o *Sort) SetSortItemList(v element.Element) { + o.sortItemList.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Sort) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + if child, err := codec.DecodeChild(raw, "SortItemList"); err == nil { + o.sortItemList.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// SortItem +// ──────────────────────────────────────────────────────── + +type SortItem struct { + element.Base + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + sortOrder *property.Enum[string] +} + +// AttributePath returns the value of the attributePath property. +func (o *SortItem) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *SortItem) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *SortItem) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *SortItem) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// SortOrder returns the value of the sortOrder property. +func (o *SortItem) SortOrder() string { + return o.sortOrder.Get() +} + +// SetSortOrder sets the value of the sortOrder property. +func (o *SortItem) SetSortOrder(v string) { + o.sortOrder.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SortItem) InitFromRaw(raw bson.Raw) { + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("SortOrder"); err == nil { + if s, ok := val.StringValueOK(); ok { o.sortOrder.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// SortItemList +// ──────────────────────────────────────────────────────── + +type SortItemList struct { + element.Base + items *property.PartList[element.Element] +} + +// ItemsItems returns the value of the items property. +func (o *SortItemList) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *SortItemList) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *SortItemList) RemoveItems(index int) { + o.items.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SortItemList) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// StartEvent +// ──────────────────────────────────────────────────────── + +type StartEvent struct { + element.Base + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *StartEvent) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *StartEvent) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *StartEvent) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *StartEvent) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StartEvent) InitFromRaw(raw bson.Raw) { + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Template +// ──────────────────────────────────────────────────────── + +type Template struct { + element.Base + arguments *property.PartList[element.Element] +} + +// ArgumentsItems returns the value of the arguments property. +func (o *Template) ArgumentsItems() []element.Element { + return o.arguments.Items() +} + +// AddArguments appends a child element to the arguments list. +func (o *Template) AddArguments(v element.Element) { + o.arguments.Append(v) +} + +// RemoveArguments removes the element at the given index from the arguments list. +func (o *Template) RemoveArguments(index int) { + o.arguments.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Template) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Arguments"); err == nil { + for _, child := range children { + o.arguments.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// StringTemplate +// ──────────────────────────────────────────────────────── + +type StringTemplate struct { + element.Base + arguments *property.PartList[element.Element] + text *property.Primitive[string] +} + +// ArgumentsItems returns the value of the arguments property. +func (o *StringTemplate) ArgumentsItems() []element.Element { + return o.arguments.Items() +} + +// AddArguments appends a child element to the arguments list. +func (o *StringTemplate) AddArguments(v element.Element) { + o.arguments.Append(v) +} + +// RemoveArguments removes the element at the given index from the arguments list. +func (o *StringTemplate) RemoveArguments(index int) { + o.arguments.Remove(index) +} + +// Text returns the value of the text property. +func (o *StringTemplate) Text() string { + return o.text.Get() +} + +// SetText sets the value of the text property. +func (o *StringTemplate) SetText(v string) { + o.text.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringTemplate) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Arguments"); err == nil { + for _, child := range children { + o.arguments.AppendFromDecode(child) + } + } + o.text.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// StringTemplateParameterValue +// ──────────────────────────────────────────────────────── + +type StringTemplateParameterValue struct { + element.Base + template *property.Part[element.Element] + typedTemplate *property.Part[element.Element] +} + +// Template returns the value of the template property. +func (o *StringTemplateParameterValue) Template() element.Element { + return o.template.Get() +} + +// SetTemplate sets the value of the template property. +func (o *StringTemplateParameterValue) SetTemplate(v element.Element) { + o.template.Set(v) +} + +// TypedTemplate returns the value of the typedTemplate property. +func (o *StringTemplateParameterValue) TypedTemplate() element.Element { + return o.typedTemplate.Get() +} + +// SetTypedTemplate sets the value of the typedTemplate property. +func (o *StringTemplateParameterValue) SetTypedTemplate(v element.Element) { + o.typedTemplate.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringTemplateParameterValue) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Template"); err == nil { + o.template.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TypedTemplate"); err == nil { + o.typedTemplate.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Subtract +// ──────────────────────────────────────────────────────── + +type Subtract struct { + element.Base + listVariableName *property.Primitive[string] + secondListOrObjectVariableName *property.Primitive[string] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *Subtract) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *Subtract) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// SecondListOrObjectVariableName returns the value of the secondListOrObjectVariableName property. +func (o *Subtract) SecondListOrObjectVariableName() string { + return o.secondListOrObjectVariableName.Get() +} + +// SetSecondListOrObjectVariableName sets the value of the secondListOrObjectVariableName property. +func (o *Subtract) SetSecondListOrObjectVariableName(v string) { + o.secondListOrObjectVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Subtract) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.secondListOrObjectVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SynchronizeAction +// ──────────────────────────────────────────────────────── + +type SynchronizeAction struct { + element.Base + errorHandlingType *property.Enum[string] + propType *property.Enum[string] + variableNames *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *SynchronizeAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *SynchronizeAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Type returns the value of the type property. +func (o *SynchronizeAction) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *SynchronizeAction) SetType(v string) { + o.propType.Set(v) +} + +// VariableNames returns the value of the variableNames property. +func (o *SynchronizeAction) VariableNames() string { + return o.variableNames.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SynchronizeAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.variableNames.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Tail +// ──────────────────────────────────────────────────────── + +type Tail struct { + element.Base + listVariableName *property.Primitive[string] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *Tail) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *Tail) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Tail) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TemplateArgument +// ──────────────────────────────────────────────────────── + +type TemplateArgument struct { + element.Base + expression *property.Primitive[string] + expressionModel *property.Part[element.Element] +} + +// Expression returns the value of the expression property. +func (o *TemplateArgument) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *TemplateArgument) SetExpression(v string) { + o.expression.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *TemplateArgument) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *TemplateArgument) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TemplateArgument) InitFromRaw(raw bson.Raw) { + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TextTemplate +// ──────────────────────────────────────────────────────── + +type TextTemplate struct { + element.Base + arguments *property.PartList[element.Element] + text *property.Part[element.Element] +} + +// ArgumentsItems returns the value of the arguments property. +func (o *TextTemplate) ArgumentsItems() []element.Element { + return o.arguments.Items() +} + +// AddArguments appends a child element to the arguments list. +func (o *TextTemplate) AddArguments(v element.Element) { + o.arguments.Append(v) +} + +// RemoveArguments removes the element at the given index from the arguments list. +func (o *TextTemplate) RemoveArguments(index int) { + o.arguments.Remove(index) +} + +// Text returns the value of the text property. +func (o *TextTemplate) Text() element.Element { + return o.text.Get() +} + +// SetText sets the value of the text property. +func (o *TextTemplate) SetText(v element.Element) { + o.text.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TextTemplate) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Arguments"); err == nil { + for _, child := range children { + o.arguments.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Text"); err == nil { + o.text.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TransformJsonAction +// ──────────────────────────────────────────────────────── + +type TransformJsonAction struct { + element.Base + errorHandlingType *property.Enum[string] + transformation *property.ByNameRef[element.Element] + inputVariableName *property.Primitive[string] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *TransformJsonAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *TransformJsonAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// TransformationQualifiedName returns the value of the transformation property. +func (o *TransformJsonAction) TransformationQualifiedName() string { + return o.transformation.QualifiedName() +} + +// SetTransformationQualifiedName sets the value of the transformation property. +func (o *TransformJsonAction) SetTransformationQualifiedName(v string) { + o.transformation.SetQualifiedName(v) +} + +// InputVariableName returns the value of the inputVariableName property. +func (o *TransformJsonAction) InputVariableName() string { + return o.inputVariableName.Get() +} + +// SetInputVariableName sets the value of the inputVariableName property. +func (o *TransformJsonAction) SetInputVariableName(v string) { + o.inputVariableName.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *TransformJsonAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *TransformJsonAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TransformJsonAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Transformation"); err == nil { + if s, ok := val.StringValueOK(); ok { o.transformation.SetFromDecode(s) } + } + o.inputVariableName.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TypedTemplate +// ──────────────────────────────────────────────────────── + +type TypedTemplate struct { + element.Base + text *property.Primitive[string] + arguments *property.PartList[element.Element] +} + +// Text returns the value of the text property. +func (o *TypedTemplate) Text() string { + return o.text.Get() +} + +// SetText sets the value of the text property. +func (o *TypedTemplate) SetText(v string) { + o.text.Set(v) +} + +// ArgumentsItems returns the value of the arguments property. +func (o *TypedTemplate) ArgumentsItems() []element.Element { + return o.arguments.Items() +} + +// AddArguments appends a child element to the arguments list. +func (o *TypedTemplate) AddArguments(v element.Element) { + o.arguments.Append(v) +} + +// RemoveArguments removes the element at the given index from the arguments list. +func (o *TypedTemplate) RemoveArguments(index int) { + o.arguments.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TypedTemplate) InitFromRaw(raw bson.Raw) { + o.text.Init(raw) + if children, err := codec.DecodeChildren(raw, "Arguments"); err == nil { + for _, child := range children { + o.arguments.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Union +// ──────────────────────────────────────────────────────── + +type Union struct { + element.Base + listVariableName *property.Primitive[string] + secondListOrObjectVariableName *property.Primitive[string] +} + +// ListVariableName returns the value of the listVariableName property. +func (o *Union) ListVariableName() string { + return o.listVariableName.Get() +} + +// SetListVariableName sets the value of the listVariableName property. +func (o *Union) SetListVariableName(v string) { + o.listVariableName.Set(v) +} + +// SecondListOrObjectVariableName returns the value of the secondListOrObjectVariableName property. +func (o *Union) SecondListOrObjectVariableName() string { + return o.secondListOrObjectVariableName.Get() +} + +// SetSecondListOrObjectVariableName sets the value of the secondListOrObjectVariableName property. +func (o *Union) SetSecondListOrObjectVariableName(v string) { + o.secondListOrObjectVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Union) InitFromRaw(raw bson.Raw) { + o.listVariableName.Init(raw) + o.secondListOrObjectVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// UnlockWorkflowAction +// ──────────────────────────────────────────────────────── + +type UnlockWorkflowAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflow *property.ByNameRef[element.Element] + workflowSelection *property.Part[element.Element] + resumeAllPausedWorkflows *property.Primitive[bool] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *UnlockWorkflowAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *UnlockWorkflowAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowQualifiedName returns the value of the workflow property. +func (o *UnlockWorkflowAction) WorkflowQualifiedName() string { + return o.workflow.QualifiedName() +} + +// SetWorkflowQualifiedName sets the value of the workflow property. +func (o *UnlockWorkflowAction) SetWorkflowQualifiedName(v string) { + o.workflow.SetQualifiedName(v) +} + +// WorkflowSelection returns the value of the workflowSelection property. +func (o *UnlockWorkflowAction) WorkflowSelection() element.Element { + return o.workflowSelection.Get() +} + +// SetWorkflowSelection sets the value of the workflowSelection property. +func (o *UnlockWorkflowAction) SetWorkflowSelection(v element.Element) { + o.workflowSelection.Set(v) +} + +// ResumeAllPausedWorkflows returns the value of the resumeAllPausedWorkflows property. +func (o *UnlockWorkflowAction) ResumeAllPausedWorkflows() bool { + return o.resumeAllPausedWorkflows.Get() +} + +// SetResumeAllPausedWorkflows sets the value of the resumeAllPausedWorkflows property. +func (o *UnlockWorkflowAction) SetResumeAllPausedWorkflows(v bool) { + o.resumeAllPausedWorkflows.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UnlockWorkflowAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Workflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.workflow.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "WorkflowSelection"); err == nil { + o.workflowSelection.SetFromDecode(child) + } + o.resumeAllPausedWorkflows.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// UnpauseOperation +// ──────────────────────────────────────────────────────── + +type UnpauseOperation struct { + element.Base + workflowVariable *property.Primitive[string] +} + +// WorkflowVariable returns the value of the workflowVariable property. +func (o *UnpauseOperation) WorkflowVariable() string { + return o.workflowVariable.Get() +} + +// SetWorkflowVariable sets the value of the workflowVariable property. +func (o *UnpauseOperation) SetWorkflowVariable(v string) { + o.workflowVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UnpauseOperation) InitFromRaw(raw bson.Raw) { + o.workflowVariable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ValidationFeedbackAction +// ──────────────────────────────────────────────────────── + +type ValidationFeedbackAction struct { + element.Base + errorHandlingType *property.Enum[string] + feedbackTemplate *property.Part[element.Element] + objectVariableName *property.Primitive[string] + attribute *property.ByNameRef[element.Element] + association *property.ByNameRef[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *ValidationFeedbackAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *ValidationFeedbackAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// FeedbackTemplate returns the value of the feedbackTemplate property. +func (o *ValidationFeedbackAction) FeedbackTemplate() element.Element { + return o.feedbackTemplate.Get() +} + +// SetFeedbackTemplate sets the value of the feedbackTemplate property. +func (o *ValidationFeedbackAction) SetFeedbackTemplate(v element.Element) { + o.feedbackTemplate.Set(v) +} + +// ObjectVariableName returns the value of the objectVariableName property. +func (o *ValidationFeedbackAction) ObjectVariableName() string { + return o.objectVariableName.Get() +} + +// SetObjectVariableName sets the value of the objectVariableName property. +func (o *ValidationFeedbackAction) SetObjectVariableName(v string) { + o.objectVariableName.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ValidationFeedbackAction) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ValidationFeedbackAction) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *ValidationFeedbackAction) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *ValidationFeedbackAction) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ValidationFeedbackAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "FeedbackTemplate"); err == nil { + o.feedbackTemplate.SetFromDecode(child) + } + o.objectVariableName.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { o.association.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// VariableExport +// ──────────────────────────────────────────────────────── + +type VariableExport struct { + element.Base + outputVariableName *property.Primitive[string] +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *VariableExport) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *VariableExport) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VariableExport) InitFromRaw(raw bson.Raw) { + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WebServiceCallAction +// ──────────────────────────────────────────────────────── + +type WebServiceCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + importedWebService *property.ByNameRef[element.Element] + serviceName *property.Primitive[string] + operationName *property.Primitive[string] + useRequestTimeOut *property.Primitive[bool] + timeOut *property.Primitive[int32] + timeOutModel *property.Part[element.Element] + timeOutExpression *property.Primitive[string] + sendNullValueChoice *property.Enum[string] + requestHeaderHandling *property.Part[element.Element] + requestBodyHandling *property.Part[element.Element] + resultHandling *property.Part[element.Element] + httpConfiguration *property.Part[element.Element] + isValidationRequired *property.Primitive[bool] + requestProxyType *property.Enum[string] + proxyConfiguration *property.Part[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *WebServiceCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *WebServiceCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// ImportedWebServiceQualifiedName returns the value of the importedWebService property. +func (o *WebServiceCallAction) ImportedWebServiceQualifiedName() string { + return o.importedWebService.QualifiedName() +} + +// SetImportedWebServiceQualifiedName sets the value of the importedWebService property. +func (o *WebServiceCallAction) SetImportedWebServiceQualifiedName(v string) { + o.importedWebService.SetQualifiedName(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *WebServiceCallAction) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *WebServiceCallAction) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// OperationName returns the value of the operationName property. +func (o *WebServiceCallAction) OperationName() string { + return o.operationName.Get() +} + +// SetOperationName sets the value of the operationName property. +func (o *WebServiceCallAction) SetOperationName(v string) { + o.operationName.Set(v) +} + +// UseRequestTimeOut returns the value of the useRequestTimeOut property. +func (o *WebServiceCallAction) UseRequestTimeOut() bool { + return o.useRequestTimeOut.Get() +} + +// SetUseRequestTimeOut sets the value of the useRequestTimeOut property. +func (o *WebServiceCallAction) SetUseRequestTimeOut(v bool) { + o.useRequestTimeOut.Set(v) +} + +// TimeOut returns the value of the timeOut property. +func (o *WebServiceCallAction) TimeOut() int32 { + return o.timeOut.Get() +} + +// SetTimeOut sets the value of the timeOut property. +func (o *WebServiceCallAction) SetTimeOut(v int32) { + o.timeOut.Set(v) +} + +// TimeOutModel returns the value of the timeOutModel property. +func (o *WebServiceCallAction) TimeOutModel() element.Element { + return o.timeOutModel.Get() +} + +// SetTimeOutModel sets the value of the timeOutModel property. +func (o *WebServiceCallAction) SetTimeOutModel(v element.Element) { + o.timeOutModel.Set(v) +} + +// TimeOutExpression returns the value of the timeOutExpression property. +func (o *WebServiceCallAction) TimeOutExpression() string { + return o.timeOutExpression.Get() +} + +// SetTimeOutExpression sets the value of the timeOutExpression property. +func (o *WebServiceCallAction) SetTimeOutExpression(v string) { + o.timeOutExpression.Set(v) +} + +// SendNullValueChoice returns the value of the sendNullValueChoice property. +func (o *WebServiceCallAction) SendNullValueChoice() string { + return o.sendNullValueChoice.Get() +} + +// SetSendNullValueChoice sets the value of the sendNullValueChoice property. +func (o *WebServiceCallAction) SetSendNullValueChoice(v string) { + o.sendNullValueChoice.Set(v) +} + +// RequestHeaderHandling returns the value of the requestHeaderHandling property. +func (o *WebServiceCallAction) RequestHeaderHandling() element.Element { + return o.requestHeaderHandling.Get() +} + +// SetRequestHeaderHandling sets the value of the requestHeaderHandling property. +func (o *WebServiceCallAction) SetRequestHeaderHandling(v element.Element) { + o.requestHeaderHandling.Set(v) +} + +// RequestBodyHandling returns the value of the requestBodyHandling property. +func (o *WebServiceCallAction) RequestBodyHandling() element.Element { + return o.requestBodyHandling.Get() +} + +// SetRequestBodyHandling sets the value of the requestBodyHandling property. +func (o *WebServiceCallAction) SetRequestBodyHandling(v element.Element) { + o.requestBodyHandling.Set(v) +} + +// ResultHandling returns the value of the resultHandling property. +func (o *WebServiceCallAction) ResultHandling() element.Element { + return o.resultHandling.Get() +} + +// SetResultHandling sets the value of the resultHandling property. +func (o *WebServiceCallAction) SetResultHandling(v element.Element) { + o.resultHandling.Set(v) +} + +// HttpConfiguration returns the value of the httpConfiguration property. +func (o *WebServiceCallAction) HttpConfiguration() element.Element { + return o.httpConfiguration.Get() +} + +// SetHttpConfiguration sets the value of the httpConfiguration property. +func (o *WebServiceCallAction) SetHttpConfiguration(v element.Element) { + o.httpConfiguration.Set(v) +} + +// IsValidationRequired returns the value of the isValidationRequired property. +func (o *WebServiceCallAction) IsValidationRequired() bool { + return o.isValidationRequired.Get() +} + +// SetIsValidationRequired sets the value of the isValidationRequired property. +func (o *WebServiceCallAction) SetIsValidationRequired(v bool) { + o.isValidationRequired.Set(v) +} + +// RequestProxyType returns the value of the requestProxyType property. +func (o *WebServiceCallAction) RequestProxyType() string { + return o.requestProxyType.Get() +} + +// SetRequestProxyType sets the value of the requestProxyType property. +func (o *WebServiceCallAction) SetRequestProxyType(v string) { + o.requestProxyType.Set(v) +} + +// ProxyConfiguration returns the value of the proxyConfiguration property. +func (o *WebServiceCallAction) ProxyConfiguration() element.Element { + return o.proxyConfiguration.Get() +} + +// SetProxyConfiguration sets the value of the proxyConfiguration property. +func (o *WebServiceCallAction) SetProxyConfiguration(v element.Element) { + o.proxyConfiguration.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WebServiceCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ImportedWebService"); err == nil { + if s, ok := val.StringValueOK(); ok { o.importedWebService.SetFromDecode(s) } + } + o.serviceName.Init(raw) + o.operationName.Init(raw) + o.useRequestTimeOut.Init(raw) + o.timeOut.Init(raw) + if child, err := codec.DecodeChild(raw, "TimeOutModel"); err == nil { + o.timeOutModel.SetFromDecode(child) + } + o.timeOutExpression.Init(raw) + if val, err := raw.LookupErr("SendNullValueChoice"); err == nil { + if s, ok := val.StringValueOK(); ok { o.sendNullValueChoice.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "RequestHeaderHandling"); err == nil { + o.requestHeaderHandling.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "RequestBodyHandling"); err == nil { + o.requestBodyHandling.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ResultHandling"); err == nil { + o.resultHandling.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "HttpConfiguration"); err == nil { + o.httpConfiguration.SetFromDecode(child) + } + o.isValidationRequired.Init(raw) + if val, err := raw.LookupErr("RequestProxyType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.requestProxyType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ProxyConfiguration"); err == nil { + o.proxyConfiguration.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// WebServiceOperationParameterMapping +// ──────────────────────────────────────────────────────── + +type WebServiceOperationParameterMapping struct { + element.Base + isChecked *property.Primitive[bool] + parameterName *property.Primitive[string] + argument *property.Primitive[string] + argumentModel *property.Part[element.Element] +} + +// IsChecked returns the value of the isChecked property. +func (o *WebServiceOperationParameterMapping) IsChecked() bool { + return o.isChecked.Get() +} + +// SetIsChecked sets the value of the isChecked property. +func (o *WebServiceOperationParameterMapping) SetIsChecked(v bool) { + o.isChecked.Set(v) +} + +// ParameterName returns the value of the parameterName property. +func (o *WebServiceOperationParameterMapping) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *WebServiceOperationParameterMapping) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// Argument returns the value of the argument property. +func (o *WebServiceOperationParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *WebServiceOperationParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// ArgumentModel returns the value of the argumentModel property. +func (o *WebServiceOperationParameterMapping) ArgumentModel() element.Element { + return o.argumentModel.Get() +} + +// SetArgumentModel sets the value of the argumentModel property. +func (o *WebServiceOperationParameterMapping) SetArgumentModel(v element.Element) { + o.argumentModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WebServiceOperationParameterMapping) InitFromRaw(raw bson.Raw) { + o.isChecked.Init(raw) + o.parameterName.Init(raw) + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "ArgumentModel"); err == nil { + o.argumentModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// WebServiceOperationAdvancedParameterMapping +// ──────────────────────────────────────────────────────── + +type WebServiceOperationAdvancedParameterMapping struct { + element.Base + isChecked *property.Primitive[bool] + parameterName *property.Primitive[string] + argument *property.Primitive[string] + argumentModel *property.Part[element.Element] + mapping *property.ByNameRef[element.Element] + mappingArgumentVariableName *property.Primitive[string] +} + +// IsChecked returns the value of the isChecked property. +func (o *WebServiceOperationAdvancedParameterMapping) IsChecked() bool { + return o.isChecked.Get() +} + +// SetIsChecked sets the value of the isChecked property. +func (o *WebServiceOperationAdvancedParameterMapping) SetIsChecked(v bool) { + o.isChecked.Set(v) +} + +// ParameterName returns the value of the parameterName property. +func (o *WebServiceOperationAdvancedParameterMapping) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *WebServiceOperationAdvancedParameterMapping) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// Argument returns the value of the argument property. +func (o *WebServiceOperationAdvancedParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *WebServiceOperationAdvancedParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// ArgumentModel returns the value of the argumentModel property. +func (o *WebServiceOperationAdvancedParameterMapping) ArgumentModel() element.Element { + return o.argumentModel.Get() +} + +// SetArgumentModel sets the value of the argumentModel property. +func (o *WebServiceOperationAdvancedParameterMapping) SetArgumentModel(v element.Element) { + o.argumentModel.Set(v) +} + +// MappingQualifiedName returns the value of the mapping property. +func (o *WebServiceOperationAdvancedParameterMapping) MappingQualifiedName() string { + return o.mapping.QualifiedName() +} + +// SetMappingQualifiedName sets the value of the mapping property. +func (o *WebServiceOperationAdvancedParameterMapping) SetMappingQualifiedName(v string) { + o.mapping.SetQualifiedName(v) +} + +// MappingArgumentVariableName returns the value of the mappingArgumentVariableName property. +func (o *WebServiceOperationAdvancedParameterMapping) MappingArgumentVariableName() string { + return o.mappingArgumentVariableName.Get() +} + +// SetMappingArgumentVariableName sets the value of the mappingArgumentVariableName property. +func (o *WebServiceOperationAdvancedParameterMapping) SetMappingArgumentVariableName(v string) { + o.mappingArgumentVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WebServiceOperationAdvancedParameterMapping) InitFromRaw(raw bson.Raw) { + o.isChecked.Init(raw) + o.parameterName.Init(raw) + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "ArgumentModel"); err == nil { + o.argumentModel.SetFromDecode(child) + } + if val, err := raw.LookupErr("Mapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.mapping.SetFromDecode(s) } + } + o.mappingArgumentVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WebServiceOperationSimpleParameterMapping +// ──────────────────────────────────────────────────────── + +type WebServiceOperationSimpleParameterMapping struct { + element.Base + isChecked *property.Primitive[bool] + parameterName *property.Primitive[string] + argument *property.Primitive[string] + argumentModel *property.Part[element.Element] + parameterPath *property.Primitive[string] +} + +// IsChecked returns the value of the isChecked property. +func (o *WebServiceOperationSimpleParameterMapping) IsChecked() bool { + return o.isChecked.Get() +} + +// SetIsChecked sets the value of the isChecked property. +func (o *WebServiceOperationSimpleParameterMapping) SetIsChecked(v bool) { + o.isChecked.Set(v) +} + +// ParameterName returns the value of the parameterName property. +func (o *WebServiceOperationSimpleParameterMapping) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *WebServiceOperationSimpleParameterMapping) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// Argument returns the value of the argument property. +func (o *WebServiceOperationSimpleParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *WebServiceOperationSimpleParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// ArgumentModel returns the value of the argumentModel property. +func (o *WebServiceOperationSimpleParameterMapping) ArgumentModel() element.Element { + return o.argumentModel.Get() +} + +// SetArgumentModel sets the value of the argumentModel property. +func (o *WebServiceOperationSimpleParameterMapping) SetArgumentModel(v element.Element) { + o.argumentModel.Set(v) +} + +// ParameterPath returns the value of the parameterPath property. +func (o *WebServiceOperationSimpleParameterMapping) ParameterPath() string { + return o.parameterPath.Get() +} + +// SetParameterPath sets the value of the parameterPath property. +func (o *WebServiceOperationSimpleParameterMapping) SetParameterPath(v string) { + o.parameterPath.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WebServiceOperationSimpleParameterMapping) InitFromRaw(raw bson.Raw) { + o.isChecked.Init(raw) + o.parameterName.Init(raw) + o.argument.Init(raw) + if child, err := codec.DecodeChild(raw, "ArgumentModel"); err == nil { + o.argumentModel.SetFromDecode(child) + } + o.parameterPath.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WhileLoopCondition +// ──────────────────────────────────────────────────────── + +type WhileLoopCondition struct { + element.Base + whileExpression *property.Primitive[string] + caption *property.Primitive[string] +} + +// WhileExpression returns the value of the whileExpression property. +func (o *WhileLoopCondition) WhileExpression() string { + return o.whileExpression.Get() +} + +// SetWhileExpression sets the value of the whileExpression property. +func (o *WhileLoopCondition) SetWhileExpression(v string) { + o.whileExpression.Set(v) +} + +// Caption returns the value of the caption property. +func (o *WhileLoopCondition) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *WhileLoopCondition) SetCaption(v string) { + o.caption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WhileLoopCondition) InitFromRaw(raw bson.Raw) { + o.whileExpression.Init(raw) + o.caption.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WorkflowCallAction +// ──────────────────────────────────────────────────────── + +type WorkflowCallAction struct { + element.Base + errorHandlingType *property.Enum[string] + workflow *property.ByNameRef[element.Element] + workflowContextVariable *property.Primitive[string] + useReturnVariable *property.Primitive[bool] + outputVariableName *property.Primitive[string] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *WorkflowCallAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *WorkflowCallAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// WorkflowQualifiedName returns the value of the workflow property. +func (o *WorkflowCallAction) WorkflowQualifiedName() string { + return o.workflow.QualifiedName() +} + +// SetWorkflowQualifiedName sets the value of the workflow property. +func (o *WorkflowCallAction) SetWorkflowQualifiedName(v string) { + o.workflow.SetQualifiedName(v) +} + +// WorkflowContextVariable returns the value of the workflowContextVariable property. +func (o *WorkflowCallAction) WorkflowContextVariable() string { + return o.workflowContextVariable.Get() +} + +// SetWorkflowContextVariable sets the value of the workflowContextVariable property. +func (o *WorkflowCallAction) SetWorkflowContextVariable(v string) { + o.workflowContextVariable.Set(v) +} + +// UseReturnVariable returns the value of the useReturnVariable property. +func (o *WorkflowCallAction) UseReturnVariable() bool { + return o.useReturnVariable.Get() +} + +// SetUseReturnVariable sets the value of the useReturnVariable property. +func (o *WorkflowCallAction) SetUseReturnVariable(v bool) { + o.useReturnVariable.Set(v) +} + +// OutputVariableName returns the value of the outputVariableName property. +func (o *WorkflowCallAction) OutputVariableName() string { + return o.outputVariableName.Get() +} + +// SetOutputVariableName sets the value of the outputVariableName property. +func (o *WorkflowCallAction) SetOutputVariableName(v string) { + o.outputVariableName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowCallAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Workflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.workflow.SetFromDecode(s) } + } + o.workflowContextVariable.Init(raw) + o.useReturnVariable.Init(raw) + o.outputVariableName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WorkflowOperationAction +// ──────────────────────────────────────────────────────── + +type WorkflowOperationAction struct { + element.Base + errorHandlingType *property.Enum[string] + operation *property.Part[element.Element] +} + +// ErrorHandlingType returns the value of the errorHandlingType property. +func (o *WorkflowOperationAction) ErrorHandlingType() string { + return o.errorHandlingType.Get() +} + +// SetErrorHandlingType sets the value of the errorHandlingType property. +func (o *WorkflowOperationAction) SetErrorHandlingType(v string) { + o.errorHandlingType.Set(v) +} + +// Operation returns the value of the operation property. +func (o *WorkflowOperationAction) Operation() element.Element { + return o.operation.Get() +} + +// SetOperation sets the value of the operation property. +func (o *WorkflowOperationAction) SetOperation(v element.Element) { + o.operation.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowOperationAction) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ErrorHandlingType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Operation"); err == nil { + o.operation.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initAbortOperation creates a AbortOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAbortOperation() *AbortOperation { + o := &AbortOperation{} + o.SetTypeName("Microflows$AbortOperation") + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 0) + o.reason = property.NewPart[element.Element]("Reason") + o.reason.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.workflowVariable, o.reason, }) + return o +} + +// NewAbortOperation creates a new AbortOperation for user code. Marked dirty (bit 63 = new element). +func NewAbortOperation() *AbortOperation { + o := initAbortOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initActionActivity creates a ActionActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initActionActivity() *ActionActivity { + o := &ActionActivity{} + o.SetTypeName("Microflows$ActionActivity") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.action = property.NewPart[element.Element]("Action") + o.action.Bind(&o.Base, 2) + o.disabled = property.NewPrimitive[bool]("Disabled", property.DecodeBool) + o.disabled.Bind(&o.Base, 3) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 4) + o.autoGenerateCaption = property.NewPrimitive[bool]("AutoGenerateCaption", property.DecodeBool) + o.autoGenerateCaption.Bind(&o.Base, 5) + o.backgroundColor = property.NewEnum[string]("BackgroundColor") + o.backgroundColor.Bind(&o.Base, 6) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, o.action, o.disabled, o.caption, o.autoGenerateCaption, o.backgroundColor, o.documentation, }) + return o +} + +// NewActionActivity creates a new ActionActivity for user code. Marked dirty (bit 63 = new element). +func NewActionActivity() *ActionActivity { + o := initActionActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAdditionalAttribute creates a AdditionalAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAdditionalAttribute() *AdditionalAttribute { + o := &AdditionalAttribute{} + o.SetTypeName("Microflows$AdditionalAttribute") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 1) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 2) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 3) + o.attributeDataType = property.NewPart[element.Element]("AttributeDataType") + o.attributeDataType.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.propType, o.value, o.attribute, o.attributeDataType, }) + return o +} + +// NewAdditionalAttribute creates a new AdditionalAttribute for user code. Marked dirty (bit 63 = new element). +func NewAdditionalAttribute() *AdditionalAttribute { + o := initAdditionalAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAdvancedRequestHandling creates a AdvancedRequestHandling with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAdvancedRequestHandling() *AdvancedRequestHandling { + o := &AdvancedRequestHandling{} + o.SetTypeName("Microflows$AdvancedRequestHandling") + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 0) + o.nullValueOption = property.NewEnum[string]("NullValueOption") + o.nullValueOption.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameterMappings, o.nullValueOption, }) + return o +} + +// NewAdvancedRequestHandling creates a new AdvancedRequestHandling for user code. Marked dirty (bit 63 = new element). +func NewAdvancedRequestHandling() *AdvancedRequestHandling { + o := initAdvancedRequestHandling() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAggregateListAction creates a AggregateListAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAggregateListAction() *AggregateListAction { + o := &AggregateListAction{} + o.SetTypeName("Microflows$AggregateAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.inputListVariableName = property.NewPrimitive[string]("InputListVariableName", property.DecodeString) + o.inputListVariableName.Bind(&o.Base, 1) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 2) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 3) + o.useExpression = property.NewPrimitive[bool]("UseExpression", property.DecodeBool) + o.useExpression.Bind(&o.Base, 4) + o.aggregateFunction = property.NewEnum[string]("AggregateFunction") + o.aggregateFunction.Bind(&o.Base, 5) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 6) + o.reduceReturnDataType = property.NewPart[element.Element]("ReduceReturnDataType") + o.reduceReturnDataType.Bind(&o.Base, 7) + o.reduceInitialValueExpression = property.NewPrimitive[string]("ReduceInitialValueExpression", property.DecodeString) + o.reduceInitialValueExpression.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.errorHandlingType, o.inputListVariableName, o.attribute, o.expression, o.useExpression, o.aggregateFunction, o.outputVariableName, o.reduceReturnDataType, o.reduceInitialValueExpression, }) + return o +} + +// NewAggregateListAction creates a new AggregateListAction for user code. Marked dirty (bit 63 = new element). +func NewAggregateListAction() *AggregateListAction { + o := initAggregateListAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAnnotation creates a Annotation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAnnotation() *Annotation { + o := &Annotation{} + o.SetTypeName("Microflows$Annotation") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, o.caption, }) + return o +} + +// NewAnnotation creates a new Annotation for user code. Marked dirty (bit 63 = new element). +func NewAnnotation() *Annotation { + o := initAnnotation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAnnotationFlow creates a AnnotationFlow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAnnotationFlow() *AnnotationFlow { + o := &AnnotationFlow{} + o.SetTypeName("Microflows$AnnotationFlow") + o.origin = property.NewByIdRef[element.Element]("OriginPointer") + o.origin.Bind(&o.Base, 0) + o.destination = property.NewByIdRef[element.Element]("DestinationPointer") + o.destination.Bind(&o.Base, 1) + o.originConnectionIndex = property.NewPrimitive[int32]("OriginConnectionIndex", property.DecodeInt32) + o.originConnectionIndex.Bind(&o.Base, 2) + o.destinationConnectionIndex = property.NewPrimitive[int32]("DestinationConnectionIndex", property.DecodeInt32) + o.destinationConnectionIndex.Bind(&o.Base, 3) + o.originBezierVector = property.NewPrimitive[string]("OriginBezierVector", property.DecodeString) + o.originBezierVector.Bind(&o.Base, 4) + o.destinationBezierVector = property.NewPrimitive[string]("DestinationBezierVector", property.DecodeString) + o.destinationBezierVector.Bind(&o.Base, 5) + o.lineType = property.NewEnum[string]("LineType") + o.lineType.Bind(&o.Base, 6) + o.line = property.NewPart[element.Element]("Line") + o.line.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.origin, o.destination, o.originConnectionIndex, o.destinationConnectionIndex, o.originBezierVector, o.destinationBezierVector, o.lineType, o.line, }) + return o +} + +// NewAnnotationFlow creates a new AnnotationFlow for user code. Marked dirty (bit 63 = new element). +func NewAnnotationFlow() *AnnotationFlow { + o := initAnnotationFlow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAppServiceCallAction creates a AppServiceCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAppServiceCallAction() *AppServiceCallAction { + o := &AppServiceCallAction{} + o.SetTypeName("Microflows$AppServiceCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.appServiceAction = property.NewByNameRef[element.Element]("AppServiceAction", "AppServices$AppServiceAction") + o.appServiceAction.Bind(&o.Base, 1) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 2) + o.useVariable = property.NewPrimitive[bool]("UseVariable", property.DecodeBool) + o.useVariable.Bind(&o.Base, 3) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.appServiceAction, o.parameterMappings, o.useVariable, o.outputVariableName, }) + return o +} + +// NewAppServiceCallAction creates a new AppServiceCallAction for user code. Marked dirty (bit 63 = new element). +func NewAppServiceCallAction() *AppServiceCallAction { + o := initAppServiceCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAppServiceCallParameterMapping creates a AppServiceCallParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAppServiceCallParameterMapping() *AppServiceCallParameterMapping { + o := &AppServiceCallParameterMapping{} + o.SetTypeName("Microflows$AppServiceCallParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "AppServices$AppServiceActionParameter") + o.parameter.Bind(&o.Base, 0) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 1) + o.argumentModel = property.NewPart[element.Element]("ArgumentModel") + o.argumentModel.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.parameter, o.argument, o.argumentModel, }) + return o +} + +// NewAppServiceCallParameterMapping creates a new AppServiceCallParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewAppServiceCallParameterMapping() *AppServiceCallParameterMapping { + o := initAppServiceCallParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initApplyJumpToOptionAction creates a ApplyJumpToOptionAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initApplyJumpToOptionAction() *ApplyJumpToOptionAction { + o := &ApplyJumpToOptionAction{} + o.SetTypeName("Microflows$ApplyJumpToOptionAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflowJumpToDetailsVariable = property.NewPrimitive[string]("WorkflowJumpToDetailsVariable", property.DecodeString) + o.workflowJumpToDetailsVariable.Bind(&o.Base, 1) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflowJumpToDetailsVariable, o.outputVariableName, }) + return o +} + +// NewApplyJumpToOptionAction creates a new ApplyJumpToOptionAction for user code. Marked dirty (bit 63 = new element). +func NewApplyJumpToOptionAction() *ApplyJumpToOptionAction { + o := initApplyJumpToOptionAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAssociationRetrieveSource creates a AssociationRetrieveSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAssociationRetrieveSource() *AssociationRetrieveSource { + o := &AssociationRetrieveSource{} + o.SetTypeName("Microflows$AssociationRetrieveSource") + o.startVariableName = property.NewPrimitive[string]("StartVariableName", property.DecodeString) + o.startVariableName.Bind(&o.Base, 0) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.startVariableName, o.association, }) + return o +} + +// NewAssociationRetrieveSource creates a new AssociationRetrieveSource for user code. Marked dirty (bit 63 = new element). +func NewAssociationRetrieveSource() *AssociationRetrieveSource { + o := initAssociationRetrieveSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAuthenticationDocumentConfig creates a AuthenticationDocumentConfig with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAuthenticationDocumentConfig() *AuthenticationDocumentConfig { + o := &AuthenticationDocumentConfig{} + o.SetTypeName("Microflows$AuthenticationDocumentConfig") + o.optForAuthDocument = property.NewPrimitive[bool]("OptForAuthDocument", property.DecodeBool) + o.optForAuthDocument.Bind(&o.Base, 0) + o.authenticationDocument = property.NewByNameRef[element.Element]("AuthenticationDocument", "Authentication$Authentication") + o.authenticationDocument.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.optForAuthDocument, o.authenticationDocument, }) + return o +} + +// NewAuthenticationDocumentConfig creates a new AuthenticationDocumentConfig for user code. Marked dirty (bit 63 = new element). +func NewAuthenticationDocumentConfig() *AuthenticationDocumentConfig { + o := initAuthenticationDocumentConfig() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBasicAuthConfig creates a BasicAuthConfig with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicAuthConfig() *BasicAuthConfig { + o := &BasicAuthConfig{} + o.SetTypeName("Microflows$BasicAuthConfig") + o.optForAuthDocument = property.NewPrimitive[bool]("OptForAuthDocument", property.DecodeBool) + o.optForAuthDocument.Bind(&o.Base, 0) + o.username = property.NewPrimitive[string]("Username", property.DecodeString) + o.username.Bind(&o.Base, 1) + o.password = property.NewPrimitive[string]("Password", property.DecodeString) + o.password.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.optForAuthDocument, o.username, o.password, }) + return o +} + +// NewBasicAuthConfig creates a new BasicAuthConfig for user code. Marked dirty (bit 63 = new element). +func NewBasicAuthConfig() *BasicAuthConfig { + o := initBasicAuthConfig() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBasicCodeActionParameterValue creates a BasicCodeActionParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicCodeActionParameterValue() *BasicCodeActionParameterValue { + o := &BasicCodeActionParameterValue{} + o.SetTypeName("Microflows$BasicCodeActionParameterValue") + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 0) + o.argumentModel = property.NewPart[element.Element]("ArgumentModel") + o.argumentModel.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.argument, o.argumentModel, }) + return o +} + +// NewBasicCodeActionParameterValue creates a new BasicCodeActionParameterValue for user code. Marked dirty (bit 63 = new element). +func NewBasicCodeActionParameterValue() *BasicCodeActionParameterValue { + o := initBasicCodeActionParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBasicJavaActionParameterValue creates a BasicJavaActionParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicJavaActionParameterValue() *BasicJavaActionParameterValue { + o := &BasicJavaActionParameterValue{} + o.SetTypeName("Microflows$BasicJavaActionParameterValue") + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 0) + o.argumentModel = property.NewPart[element.Element]("ArgumentModel") + o.argumentModel.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.argument, o.argumentModel, }) + return o +} + +// NewBasicJavaActionParameterValue creates a new BasicJavaActionParameterValue for user code. Marked dirty (bit 63 = new element). +func NewBasicJavaActionParameterValue() *BasicJavaActionParameterValue { + o := initBasicJavaActionParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBezierCurve creates a BezierCurve with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBezierCurve() *BezierCurve { + o := &BezierCurve{} + o.SetTypeName("Microflows$BezierCurve") + o.originControlVector = property.NewPrimitive[string]("OriginControlVector", property.DecodeString) + o.originControlVector.Bind(&o.Base, 0) + o.destinationControlVector = property.NewPrimitive[string]("DestinationControlVector", property.DecodeString) + o.destinationControlVector.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.originControlVector, o.destinationControlVector, }) + return o +} + +// NewBezierCurve creates a new BezierCurve for user code. Marked dirty (bit 63 = new element). +func NewBezierCurve() *BezierCurve { + o := initBezierCurve() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBinaryRequestHandling creates a BinaryRequestHandling with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBinaryRequestHandling() *BinaryRequestHandling { + o := &BinaryRequestHandling{} + o.SetTypeName("Microflows$BinaryRequestHandling") + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 0) + o.expressionModel = property.NewPart[element.Element]("ExpressionModel") + o.expressionModel.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.expression, o.expressionModel, }) + return o +} + +// NewBinaryRequestHandling creates a new BinaryRequestHandling for user code. Marked dirty (bit 63 = new element). +func NewBinaryRequestHandling() *BinaryRequestHandling { + o := initBinaryRequestHandling() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBodyVariable creates a BodyVariable with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBodyVariable() *BodyVariable { + o := &BodyVariable{} + o.SetTypeName("Microflows$BodyVariable") + o.variableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.variableName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.variableName, }) + return o +} + +// NewBodyVariable creates a new BodyVariable for user code. Marked dirty (bit 63 = new element). +func NewBodyVariable() *BodyVariable { + o := initBodyVariable() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBreakEvent creates a BreakEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBreakEvent() *BreakEvent { + o := &BreakEvent{} + o.SetTypeName("Microflows$BreakEvent") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, }) + return o +} + +// NewBreakEvent creates a new BreakEvent for user code. Marked dirty (bit 63 = new element). +func NewBreakEvent() *BreakEvent { + o := initBreakEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCallExternalAction creates a CallExternalAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCallExternalAction() *CallExternalAction { + o := &CallExternalAction{} + o.SetTypeName("Microflows$CallExternalAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.consumedODataService = property.NewByNameRef[element.Element]("ConsumedODataService", "Rest$ConsumedODataService") + o.consumedODataService.Bind(&o.Base, 1) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 2) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 3) + o.variableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.variableName.Bind(&o.Base, 4) + o.variableDataType = property.NewPart[element.Element]("VariableDataType") + o.variableDataType.Bind(&o.Base, 5) + o.includedAssociations = property.NewPartList[element.Element]("IncludedAssociations") + o.includedAssociations.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.errorHandlingType, o.consumedODataService, o.name, o.parameterMappings, o.variableName, o.variableDataType, o.includedAssociations, }) + return o +} + +// NewCallExternalAction creates a new CallExternalAction for user code. Marked dirty (bit 63 = new element). +func NewCallExternalAction() *CallExternalAction { + o := initCallExternalAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCancelSynchronizationAction creates a CancelSynchronizationAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCancelSynchronizationAction() *CancelSynchronizationAction { + o := &CancelSynchronizationAction{} + o.SetTypeName("Microflows$CancelSynchronizationAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.errorHandlingType, }) + return o +} + +// NewCancelSynchronizationAction creates a new CancelSynchronizationAction for user code. Marked dirty (bit 63 = new element). +func NewCancelSynchronizationAction() *CancelSynchronizationAction { + o := initCancelSynchronizationAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCastAction creates a CastAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCastAction() *CastAction { + o := &CastAction{} + o.SetTypeName("Microflows$CastAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.errorHandlingType, o.outputVariableName, }) + return o +} + +// NewCastAction creates a new CastAction for user code. Marked dirty (bit 63 = new element). +func NewCastAction() *CastAction { + o := initCastAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initChangeListAction creates a ChangeListAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initChangeListAction() *ChangeListAction { + o := &ChangeListAction{} + o.SetTypeName("Microflows$ChangeListAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.changeVariableName = property.NewPrimitive[string]("ChangeVariableName", property.DecodeString) + o.changeVariableName.Bind(&o.Base, 1) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 2) + o.valueModel = property.NewPart[element.Element]("ValueModel") + o.valueModel.Bind(&o.Base, 3) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.changeVariableName, o.value, o.valueModel, o.propType, }) + return o +} + +// NewChangeListAction creates a new ChangeListAction for user code. Marked dirty (bit 63 = new element). +func NewChangeListAction() *ChangeListAction { + o := initChangeListAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initChangeObjectAction creates a ChangeObjectAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initChangeObjectAction() *ChangeObjectAction { + o := &ChangeObjectAction{} + o.SetTypeName("Microflows$ChangeAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 1) + o.refreshInClient = property.NewPrimitive[bool]("RefreshInClient", property.DecodeBool) + o.refreshInClient.Bind(&o.Base, 2) + o.commit = property.NewEnum[string]("Commit") + o.commit.Bind(&o.Base, 3) + o.changeVariableName = property.NewPrimitive[string]("ChangeVariableName", property.DecodeString) + o.changeVariableName.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.items, o.refreshInClient, o.commit, o.changeVariableName, }) + return o +} + +// NewChangeObjectAction creates a new ChangeObjectAction for user code. Marked dirty (bit 63 = new element). +func NewChangeObjectAction() *ChangeObjectAction { + o := initChangeObjectAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initChangeVariableAction creates a ChangeVariableAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initChangeVariableAction() *ChangeVariableAction { + o := &ChangeVariableAction{} + o.SetTypeName("Microflows$ChangeVariableAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.changeVariableName = property.NewPrimitive[string]("ChangeVariableName", property.DecodeString) + o.changeVariableName.Bind(&o.Base, 1) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 2) + o.valueModel = property.NewPart[element.Element]("ValueModel") + o.valueModel.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.changeVariableName, o.value, o.valueModel, }) + return o +} + +// NewChangeVariableAction creates a new ChangeVariableAction for user code. Marked dirty (bit 63 = new element). +func NewChangeVariableAction() *ChangeVariableAction { + o := initChangeVariableAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initClearFromClientAction creates a ClearFromClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initClearFromClientAction() *ClearFromClientAction { + o := &ClearFromClientAction{} + o.SetTypeName("Microflows$ClearFromClientAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.errorHandlingType, o.entity, }) + return o +} + +// NewClearFromClientAction creates a new ClearFromClientAction for user code. Marked dirty (bit 63 = new element). +func NewClearFromClientAction() *ClearFromClientAction { + o := initClearFromClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCloseFormAction creates a CloseFormAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCloseFormAction() *CloseFormAction { + o := &CloseFormAction{} + o.SetTypeName("Microflows$CloseFormAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.numberOfPages = property.NewPrimitive[int32]("NumberOfPages", property.DecodeInt32) + o.numberOfPages.Bind(&o.Base, 1) + o.numberOfPagesToClose = property.NewPrimitive[string]("NumberOfPagesToClose", property.DecodeString) + o.numberOfPagesToClose.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.numberOfPages, o.numberOfPagesToClose, }) + return o +} + +// NewCloseFormAction creates a new CloseFormAction for user code. Marked dirty (bit 63 = new element). +func NewCloseFormAction() *CloseFormAction { + o := initCloseFormAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCommitAction creates a CommitAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCommitAction() *CommitAction { + o := &CommitAction{} + o.SetTypeName("Microflows$CommitAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.withEvents = property.NewPrimitive[bool]("WithEvents", property.DecodeBool) + o.withEvents.Bind(&o.Base, 1) + o.commitVariableName = property.NewPrimitive[string]("CommitVariableName", property.DecodeString) + o.commitVariableName.Bind(&o.Base, 2) + o.refreshInClient = property.NewPrimitive[bool]("RefreshInClient", property.DecodeBool) + o.refreshInClient.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.withEvents, o.commitVariableName, o.refreshInClient, }) + return o +} + +// NewCommitAction creates a new CommitAction for user code. Marked dirty (bit 63 = new element). +func NewCommitAction() *CommitAction { + o := initCommitAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConstantRange creates a ConstantRange with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConstantRange() *ConstantRange { + o := &ConstantRange{} + o.SetTypeName("Microflows$ConstantRange") + o.singleObject = property.NewPrimitive[bool]("SingleObject", property.DecodeBool) + o.singleObject.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.singleObject, }) + return o +} + +// NewConstantRange creates a new ConstantRange for user code. Marked dirty (bit 63 = new element). +func NewConstantRange() *ConstantRange { + o := initConstantRange() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initContains creates a Contains with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initContains() *Contains { + o := &Contains{} + o.SetTypeName("Microflows$Contains") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.secondListOrObjectVariableName = property.NewPrimitive[string]("SecondListOrObjectVariableName", property.DecodeString) + o.secondListOrObjectVariableName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.listVariableName, o.secondListOrObjectVariableName, }) + return o +} + +// NewContains creates a new Contains for user code. Marked dirty (bit 63 = new element). +func NewContains() *Contains { + o := initContains() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initContinueEvent creates a ContinueEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initContinueEvent() *ContinueEvent { + o := &ContinueEvent{} + o.SetTypeName("Microflows$ContinueEvent") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, }) + return o +} + +// NewContinueEvent creates a new ContinueEvent for user code. Marked dirty (bit 63 = new element). +func NewContinueEvent() *ContinueEvent { + o := initContinueEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initContinueOperation creates a ContinueOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initContinueOperation() *ContinueOperation { + o := &ContinueOperation{} + o.SetTypeName("Microflows$ContinueOperation") + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.workflowVariable, }) + return o +} + +// NewContinueOperation creates a new ContinueOperation for user code. Marked dirty (bit 63 = new element). +func NewContinueOperation() *ContinueOperation { + o := initContinueOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCounterMeterAction creates a CounterMeterAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCounterMeterAction() *CounterMeterAction { + o := &CounterMeterAction{} + o.SetTypeName("Microflows$CounterMeterAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.tags = property.NewPartList[element.Element]("Tags") + o.tags.Bind(&o.Base, 3) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.name, o.description, o.tags, o.value, }) + return o +} + +// NewCounterMeterAction creates a new CounterMeterAction for user code. Marked dirty (bit 63 = new element). +func NewCounterMeterAction() *CounterMeterAction { + o := initCounterMeterAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCreateListAction creates a CreateListAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCreateListAction() *CreateListAction { + o := &CreateListAction{} + o.SetTypeName("Microflows$CreateListAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 1) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.entity, o.outputVariableName, }) + return o +} + +// NewCreateListAction creates a new CreateListAction for user code. Marked dirty (bit 63 = new element). +func NewCreateListAction() *CreateListAction { + o := initCreateListAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCreateObjectAction creates a CreateObjectAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCreateObjectAction() *CreateObjectAction { + o := &CreateObjectAction{} + o.SetTypeName("Microflows$CreateChangeAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 1) + o.refreshInClient = property.NewPrimitive[bool]("RefreshInClient", property.DecodeBool) + o.refreshInClient.Bind(&o.Base, 2) + o.commit = property.NewEnum[string]("Commit") + o.commit.Bind(&o.Base, 3) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 4) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.errorHandlingType, o.items, o.refreshInClient, o.commit, o.entity, o.outputVariableName, }) + return o +} + +// NewCreateObjectAction creates a new CreateObjectAction for user code. Marked dirty (bit 63 = new element). +func NewCreateObjectAction() *CreateObjectAction { + o := initCreateObjectAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCreateVariableAction creates a CreateVariableAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCreateVariableAction() *CreateVariableAction { + o := &CreateVariableAction{} + o.SetTypeName("Microflows$CreateVariableAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.variableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.variableName.Bind(&o.Base, 1) + o.variableDataType = property.NewPrimitive[string]("VariableDataType", property.DecodeString) + o.variableDataType.Bind(&o.Base, 2) + o.variableType = property.NewPart[element.Element]("VariableType") + o.variableType.Bind(&o.Base, 3) + o.initialValue = property.NewPrimitive[string]("InitialValue", property.DecodeString) + o.initialValue.Bind(&o.Base, 4) + o.initialValueModel = property.NewPart[element.Element]("InitialValueModel") + o.initialValueModel.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.errorHandlingType, o.variableName, o.variableDataType, o.variableType, o.initialValue, o.initialValueModel, }) + return o +} + +// NewCreateVariableAction creates a new CreateVariableAction for user code. Marked dirty (bit 63 = new element). +func NewCreateVariableAction() *CreateVariableAction { + o := initCreateVariableAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomBlobDocumentCodeActionParameterValue creates a CustomBlobDocumentCodeActionParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomBlobDocumentCodeActionParameterValue() *CustomBlobDocumentCodeActionParameterValue { + o := &CustomBlobDocumentCodeActionParameterValue{} + o.SetTypeName("Microflows$CustomBlobDocumentCodeActionParameterValue") + o.customDocument = property.NewByNameRef[element.Element]("CustomDocument", "CustomBlobDocuments$CustomBlobDocument") + o.customDocument.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.customDocument, }) + return o +} + +// NewCustomBlobDocumentCodeActionParameterValue creates a new CustomBlobDocumentCodeActionParameterValue for user code. Marked dirty (bit 63 = new element). +func NewCustomBlobDocumentCodeActionParameterValue() *CustomBlobDocumentCodeActionParameterValue { + o := initCustomBlobDocumentCodeActionParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomRange creates a CustomRange with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomRange() *CustomRange { + o := &CustomRange{} + o.SetTypeName("Microflows$CustomRange") + o.limitExpression = property.NewPrimitive[string]("LimitExpression", property.DecodeString) + o.limitExpression.Bind(&o.Base, 0) + o.offsetExpression = property.NewPrimitive[string]("OffsetExpression", property.DecodeString) + o.offsetExpression.Bind(&o.Base, 1) + o.limitExpressionModel = property.NewPart[element.Element]("LimitExpressionModel") + o.limitExpressionModel.Bind(&o.Base, 2) + o.offsetExpressionModel = property.NewPart[element.Element]("OffsetExpressionModel") + o.offsetExpressionModel.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.limitExpression, o.offsetExpression, o.limitExpressionModel, o.offsetExpressionModel, }) + return o +} + +// NewCustomRange creates a new CustomRange for user code. Marked dirty (bit 63 = new element). +func NewCustomRange() *CustomRange { + o := initCustomRange() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomRequestHandling creates a CustomRequestHandling with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomRequestHandling() *CustomRequestHandling { + o := &CustomRequestHandling{} + o.SetTypeName("Microflows$CustomRequestHandling") + o.template = property.NewPart[element.Element]("Template") + o.template.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.template, }) + return o +} + +// NewCustomRequestHandling creates a new CustomRequestHandling for user code. Marked dirty (bit 63 = new element). +func NewCustomRequestHandling() *CustomRequestHandling { + o := initCustomRequestHandling() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDatabaseRetrieveSource creates a DatabaseRetrieveSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDatabaseRetrieveSource() *DatabaseRetrieveSource { + o := &DatabaseRetrieveSource{} + o.SetTypeName("Microflows$DatabaseRetrieveSource") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.propRange = property.NewPart[element.Element]("Range") + o.propRange.Bind(&o.Base, 1) + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 2) + o.sortItemList = property.NewPart[element.Element]("SortItemList") + o.sortItemList.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.entity, o.propRange, o.xPathConstraint, o.sortItemList, }) + return o +} + +// NewDatabaseRetrieveSource creates a new DatabaseRetrieveSource for user code. Marked dirty (bit 63 = new element). +func NewDatabaseRetrieveSource() *DatabaseRetrieveSource { + o := initDatabaseRetrieveSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDeleteAction creates a DeleteAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDeleteAction() *DeleteAction { + o := &DeleteAction{} + o.SetTypeName("Microflows$DeleteAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.deleteVariableName = property.NewPrimitive[string]("DeleteVariableName", property.DecodeString) + o.deleteVariableName.Bind(&o.Base, 1) + o.refreshInClient = property.NewPrimitive[bool]("RefreshInClient", property.DecodeBool) + o.refreshInClient.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.deleteVariableName, o.refreshInClient, }) + return o +} + +// NewDeleteAction creates a new DeleteAction for user code. Marked dirty (bit 63 = new element). +func NewDeleteAction() *DeleteAction { + o := initDeleteAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDeleteExternalObject creates a DeleteExternalObject with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDeleteExternalObject() *DeleteExternalObject { + o := &DeleteExternalObject{} + o.SetTypeName("Microflows$DeleteExternalObject") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.deleteVariableName = property.NewPrimitive[string]("DeleteVariableName", property.DecodeString) + o.deleteVariableName.Bind(&o.Base, 1) + o.refreshInClient = property.NewPrimitive[bool]("RefreshInClient", property.DecodeBool) + o.refreshInClient.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.deleteVariableName, o.refreshInClient, }) + return o +} + +// NewDeleteExternalObject creates a new DeleteExternalObject for user code. Marked dirty (bit 63 = new element). +func NewDeleteExternalObject() *DeleteExternalObject { + o := initDeleteExternalObject() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDocumentTemplateParameterMapping creates a DocumentTemplateParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDocumentTemplateParameterMapping() *DocumentTemplateParameterMapping { + o := &DocumentTemplateParameterMapping{} + o.SetTypeName("Microflows$DocumentTemplateParameterMapping") + o.widgetName = property.NewPrimitive[string]("WidgetName", property.DecodeString) + o.widgetName.Bind(&o.Base, 0) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 1) + o.argumentModel = property.NewPart[element.Element]("ArgumentModel") + o.argumentModel.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.widgetName, o.argument, o.argumentModel, }) + return o +} + +// NewDocumentTemplateParameterMapping creates a new DocumentTemplateParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewDocumentTemplateParameterMapping() *DocumentTemplateParameterMapping { + o := initDocumentTemplateParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDownloadFileAction creates a DownloadFileAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDownloadFileAction() *DownloadFileAction { + o := &DownloadFileAction{} + o.SetTypeName("Microflows$DownloadFileAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.fileDocumentVariableName = property.NewPrimitive[string]("FileDocumentVariableName", property.DecodeString) + o.fileDocumentVariableName.Bind(&o.Base, 1) + o.showFileInBrowser = property.NewPrimitive[bool]("ShowFileInBrowser", property.DecodeBool) + o.showFileInBrowser.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.fileDocumentVariableName, o.showFileInBrowser, }) + return o +} + +// NewDownloadFileAction creates a new DownloadFileAction for user code. Marked dirty (bit 63 = new element). +func NewDownloadFileAction() *DownloadFileAction { + o := initDownloadFileAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEmailConnectionConfig creates a EmailConnectionConfig with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEmailConnectionConfig() *EmailConnectionConfig { + o := &EmailConnectionConfig{} + o.SetTypeName("Microflows$EmailConnectionConfig") + o.emailId = property.NewPrimitive[string]("EmailId", property.DecodeString) + o.emailId.Bind(&o.Base, 0) + o.protocol = property.NewEnum[string]("Protocol") + o.protocol.Bind(&o.Base, 1) + o.host = property.NewPrimitive[string]("Host", property.DecodeString) + o.host.Bind(&o.Base, 2) + o.port = property.NewPrimitive[string]("Port", property.DecodeString) + o.port.Bind(&o.Base, 3) + o.securityType = property.NewEnum[string]("SecurityType") + o.securityType.Bind(&o.Base, 4) + o.checkServerIdentity = property.NewPrimitive[bool]("CheckServerIdentity", property.DecodeBool) + o.checkServerIdentity.Bind(&o.Base, 5) + o.connectionTimeout = property.NewPrimitive[int32]("ConnectionTimeout", property.DecodeInt32) + o.connectionTimeout.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.emailId, o.protocol, o.host, o.port, o.securityType, o.checkServerIdentity, o.connectionTimeout, }) + return o +} + +// NewEmailConnectionConfig creates a new EmailConnectionConfig for user code. Marked dirty (bit 63 = new element). +func NewEmailConnectionConfig() *EmailConnectionConfig { + o := initEmailConnectionConfig() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEmailMessage creates a EmailMessage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEmailMessage() *EmailMessage { + o := &EmailMessage{} + o.SetTypeName("Microflows$EmailMessage") + o.to = property.NewPrimitive[string]("To", property.DecodeString) + o.to.Bind(&o.Base, 0) + o.cc = property.NewPrimitive[string]("Cc", property.DecodeString) + o.cc.Bind(&o.Base, 1) + o.bcc = property.NewPrimitive[string]("Bcc", property.DecodeString) + o.bcc.Bind(&o.Base, 2) + o.subject = property.NewPrimitive[string]("Subject", property.DecodeString) + o.subject.Bind(&o.Base, 3) + o.messageBodyPlainText = property.NewPrimitive[string]("MessageBodyPlainText", property.DecodeString) + o.messageBodyPlainText.Bind(&o.Base, 4) + o.messageBodyHtml = property.NewPrimitive[string]("MessageBodyHtml", property.DecodeString) + o.messageBodyHtml.Bind(&o.Base, 5) + o.attachments = property.NewByNameRefList[element.Element]("Attachments", "DomainModels$Entity") + o.attachments.Bind(&o.Base, 6) + o.attachment = property.NewPrimitive[string]("Attachment", property.DecodeString) + o.attachment.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.to, o.cc, o.bcc, o.subject, o.messageBodyPlainText, o.messageBodyHtml, o.attachments, o.attachment, }) + return o +} + +// NewEmailMessage creates a new EmailMessage for user code. Marked dirty (bit 63 = new element). +func NewEmailMessage() *EmailMessage { + o := initEmailMessage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEndEvent creates a EndEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEndEvent() *EndEvent { + o := &EndEvent{} + o.SetTypeName("Microflows$EndEvent") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.returnValue = property.NewPrimitive[string]("ReturnValue", property.DecodeString) + o.returnValue.Bind(&o.Base, 2) + o.returnValueModel = property.NewPart[element.Element]("ReturnValueModel") + o.returnValueModel.Bind(&o.Base, 3) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, o.returnValue, o.returnValueModel, o.documentation, }) + return o +} + +// NewEndEvent creates a new EndEvent for user code. Marked dirty (bit 63 = new element). +func NewEndEvent() *EndEvent { + o := initEndEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityTypeCodeActionParameterValue creates a EntityTypeCodeActionParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityTypeCodeActionParameterValue() *EntityTypeCodeActionParameterValue { + o := &EntityTypeCodeActionParameterValue{} + o.SetTypeName("Microflows$EntityTypeCodeActionParameterValue") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.entity, }) + return o +} + +// NewEntityTypeCodeActionParameterValue creates a new EntityTypeCodeActionParameterValue for user code. Marked dirty (bit 63 = new element). +func NewEntityTypeCodeActionParameterValue() *EntityTypeCodeActionParameterValue { + o := initEntityTypeCodeActionParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityTypeJavaActionParameterValue creates a EntityTypeJavaActionParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityTypeJavaActionParameterValue() *EntityTypeJavaActionParameterValue { + o := &EntityTypeJavaActionParameterValue{} + o.SetTypeName("Microflows$EntityTypeJavaActionParameterValue") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.entity, }) + return o +} + +// NewEntityTypeJavaActionParameterValue creates a new EntityTypeJavaActionParameterValue for user code. Marked dirty (bit 63 = new element). +func NewEntityTypeJavaActionParameterValue() *EntityTypeJavaActionParameterValue { + o := initEntityTypeJavaActionParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEnumerationCase creates a EnumerationCase with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEnumerationCase() *EnumerationCase { + o := &EnumerationCase{} + o.SetTypeName("Microflows$EnumerationCase") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value, }) + return o +} + +// NewEnumerationCase creates a new EnumerationCase for user code. Marked dirty (bit 63 = new element). +func NewEnumerationCase() *EnumerationCase { + o := initEnumerationCase() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initErrorEvent creates a ErrorEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initErrorEvent() *ErrorEvent { + o := &ErrorEvent{} + o.SetTypeName("Microflows$ErrorEvent") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, }) + return o +} + +// NewErrorEvent creates a new ErrorEvent for user code. Marked dirty (bit 63 = new element). +func NewErrorEvent() *ErrorEvent { + o := initErrorEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExclusiveMerge creates a ExclusiveMerge with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExclusiveMerge() *ExclusiveMerge { + o := &ExclusiveMerge{} + o.SetTypeName("Microflows$ExclusiveMerge") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, }) + return o +} + +// NewExclusiveMerge creates a new ExclusiveMerge for user code. Marked dirty (bit 63 = new element). +func NewExclusiveMerge() *ExclusiveMerge { + o := initExclusiveMerge() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExclusiveSplit creates a ExclusiveSplit with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExclusiveSplit() *ExclusiveSplit { + o := &ExclusiveSplit{} + o.SetTypeName("Microflows$ExclusiveSplit") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.splitCondition = property.NewPart[element.Element]("SplitCondition") + o.splitCondition.Bind(&o.Base, 2) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 3) + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 4) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, o.splitCondition, o.caption, o.errorHandlingType, o.documentation, }) + return o +} + +// NewExclusiveSplit creates a new ExclusiveSplit for user code. Marked dirty (bit 63 = new element). +func NewExclusiveSplit() *ExclusiveSplit { + o := initExclusiveSplit() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExportMappingJavaActionParameterValue creates a ExportMappingJavaActionParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExportMappingJavaActionParameterValue() *ExportMappingJavaActionParameterValue { + o := &ExportMappingJavaActionParameterValue{} + o.SetTypeName("Microflows$ExportMappingJavaActionParameterValue") + o.exportMapping = property.NewByNameRef[element.Element]("ExportMapping", "ExportMappings$ExportMapping") + o.exportMapping.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.exportMapping, }) + return o +} + +// NewExportMappingJavaActionParameterValue creates a new ExportMappingJavaActionParameterValue for user code. Marked dirty (bit 63 = new element). +func NewExportMappingJavaActionParameterValue() *ExportMappingJavaActionParameterValue { + o := initExportMappingJavaActionParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExportMappingParameterValue creates a ExportMappingParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExportMappingParameterValue() *ExportMappingParameterValue { + o := &ExportMappingParameterValue{} + o.SetTypeName("Microflows$ExportMappingParameterValue") + o.exportMapping = property.NewByNameRef[element.Element]("ExportMapping", "ExportMappings$ExportMapping") + o.exportMapping.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.exportMapping, }) + return o +} + +// NewExportMappingParameterValue creates a new ExportMappingParameterValue for user code. Marked dirty (bit 63 = new element). +func NewExportMappingParameterValue() *ExportMappingParameterValue { + o := initExportMappingParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExportXmlAction creates a ExportXmlAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExportXmlAction() *ExportXmlAction { + o := &ExportXmlAction{} + o.SetTypeName("Microflows$ExportXmlAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.mapping = property.NewByNameRef[element.Element]("Mapping", "ExportMappings$ExportMapping") + o.mapping.Bind(&o.Base, 1) + o.mappingArgumentVariableName = property.NewPrimitive[string]("MappingArgumentVariableName", property.DecodeString) + o.mappingArgumentVariableName.Bind(&o.Base, 2) + o.resultHandling = property.NewPart[element.Element]("ResultHandling") + o.resultHandling.Bind(&o.Base, 3) + o.outputMethod = property.NewPart[element.Element]("OutputMethod") + o.outputMethod.Bind(&o.Base, 4) + o.isValidationRequired = property.NewPrimitive[bool]("IsValidationRequired", property.DecodeBool) + o.isValidationRequired.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.errorHandlingType, o.mapping, o.mappingArgumentVariableName, o.resultHandling, o.outputMethod, o.isValidationRequired, }) + return o +} + +// NewExportXmlAction creates a new ExportXmlAction for user code. Marked dirty (bit 63 = new element). +func NewExportXmlAction() *ExportXmlAction { + o := initExportXmlAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExpressionSplitCondition creates a ExpressionSplitCondition with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExpressionSplitCondition() *ExpressionSplitCondition { + o := &ExpressionSplitCondition{} + o.SetTypeName("Microflows$ExpressionSplitCondition") + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 0) + o.expressionModel = property.NewPart[element.Element]("ExpressionModel") + o.expressionModel.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.expression, o.expressionModel, }) + return o +} + +// NewExpressionSplitCondition creates a new ExpressionSplitCondition for user code. Marked dirty (bit 63 = new element). +func NewExpressionSplitCondition() *ExpressionSplitCondition { + o := initExpressionSplitCondition() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExternalActionParameterMapping creates a ExternalActionParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExternalActionParameterMapping() *ExternalActionParameterMapping { + o := &ExternalActionParameterMapping{} + o.SetTypeName("Microflows$ExternalActionParameterMapping") + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 0) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 1) + o.canBeEmpty = property.NewPrimitive[bool]("CanBeEmpty", property.DecodeBool) + o.canBeEmpty.Bind(&o.Base, 2) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 3) + o.includedAssociations = property.NewPartList[element.Element]("IncludedAssociations") + o.includedAssociations.Bind(&o.Base, 4) + o.additionalAttributes = property.NewPartList[element.Element]("AdditionalAttributes") + o.additionalAttributes.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.parameterName, o.parameterType, o.canBeEmpty, o.argument, o.includedAssociations, o.additionalAttributes, }) + return o +} + +// NewExternalActionParameterMapping creates a new ExternalActionParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewExternalActionParameterMapping() *ExternalActionParameterMapping { + o := initExternalActionParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFileDocumentExport creates a FileDocumentExport with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFileDocumentExport() *FileDocumentExport { + o := &FileDocumentExport{} + o.SetTypeName("ExportXmlAction$FileDocumentExport") + o.targetDocumentVariableName = property.NewPrimitive[string]("TargetDocumentVariableName", property.DecodeString) + o.targetDocumentVariableName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.targetDocumentVariableName, }) + return o +} + +// NewFileDocumentExport creates a new FileDocumentExport for user code. Marked dirty (bit 63 = new element). +func NewFileDocumentExport() *FileDocumentExport { + o := initFileDocumentExport() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFilter creates a Filter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFilter() *Filter { + o := &Filter{} + o.SetTypeName("Microflows$Filter") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 1) + o.expressionModel = property.NewPart[element.Element]("ExpressionModel") + o.expressionModel.Bind(&o.Base, 2) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 3) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.listVariableName, o.expression, o.expressionModel, o.attribute, o.association, }) + return o +} + +// NewFilter creates a new Filter for user code. Marked dirty (bit 63 = new element). +func NewFilter() *Filter { + o := initFilter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFilterByExpression creates a FilterByExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFilterByExpression() *FilterByExpression { + o := &FilterByExpression{} + o.SetTypeName("Microflows$FilterByExpression") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 1) + o.expressionModel = property.NewPart[element.Element]("ExpressionModel") + o.expressionModel.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.listVariableName, o.expression, o.expressionModel, }) + return o +} + +// NewFilterByExpression creates a new FilterByExpression for user code. Marked dirty (bit 63 = new element). +func NewFilterByExpression() *FilterByExpression { + o := initFilterByExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFind creates a Find with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFind() *Find { + o := &Find{} + o.SetTypeName("Microflows$Find") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 1) + o.expressionModel = property.NewPart[element.Element]("ExpressionModel") + o.expressionModel.Bind(&o.Base, 2) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 3) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.listVariableName, o.expression, o.expressionModel, o.attribute, o.association, }) + return o +} + +// NewFind creates a new Find for user code. Marked dirty (bit 63 = new element). +func NewFind() *Find { + o := initFind() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFindByExpression creates a FindByExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFindByExpression() *FindByExpression { + o := &FindByExpression{} + o.SetTypeName("Microflows$FindByExpression") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 1) + o.expressionModel = property.NewPart[element.Element]("ExpressionModel") + o.expressionModel.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.listVariableName, o.expression, o.expressionModel, }) + return o +} + +// NewFindByExpression creates a new FindByExpression for user code. Marked dirty (bit 63 = new element). +func NewFindByExpression() *FindByExpression { + o := initFindByExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFormDataPart creates a FormDataPart with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFormDataPart() *FormDataPart { + o := &FormDataPart{} + o.SetTypeName("Microflows$FormDataPart") + o.key = property.NewPrimitive[string]("Key", property.DecodeString) + o.key.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.valueModel = property.NewPart[element.Element]("ValueModel") + o.valueModel.Bind(&o.Base, 2) + o.headerEntries = property.NewPartList[element.Element]("HeaderEntries") + o.headerEntries.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.key, o.value, o.valueModel, o.headerEntries, }) + return o +} + +// NewFormDataPart creates a new FormDataPart for user code. Marked dirty (bit 63 = new element). +func NewFormDataPart() *FormDataPart { + o := initFormDataPart() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFormDataRequestHandling creates a FormDataRequestHandling with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFormDataRequestHandling() *FormDataRequestHandling { + o := &FormDataRequestHandling{} + o.SetTypeName("Microflows$FormDataRequestHandling") + o.parts = property.NewPartList[element.Element]("Parts") + o.parts.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.parts, }) + return o +} + +// NewFormDataRequestHandling creates a new FormDataRequestHandling for user code. Marked dirty (bit 63 = new element). +func NewFormDataRequestHandling() *FormDataRequestHandling { + o := initFormDataRequestHandling() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGaugeMeterAction creates a GaugeMeterAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGaugeMeterAction() *GaugeMeterAction { + o := &GaugeMeterAction{} + o.SetTypeName("Microflows$GaugeMeterAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.tags = property.NewPartList[element.Element]("Tags") + o.tags.Bind(&o.Base, 3) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.name, o.description, o.tags, o.value, }) + return o +} + +// NewGaugeMeterAction creates a new GaugeMeterAction for user code. Marked dirty (bit 63 = new element). +func NewGaugeMeterAction() *GaugeMeterAction { + o := initGaugeMeterAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGenerateDocumentAction creates a GenerateDocumentAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGenerateDocumentAction() *GenerateDocumentAction { + o := &GenerateDocumentAction{} + o.SetTypeName("Microflows$GenerateDocumentAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.fileVariableName = property.NewPrimitive[string]("FileVariableName", property.DecodeString) + o.fileVariableName.Bind(&o.Base, 1) + o.languageVariableName = property.NewPrimitive[string]("LanguageVariableName", property.DecodeString) + o.languageVariableName.Bind(&o.Base, 2) + o.documentType = property.NewEnum[string]("DocumentType") + o.documentType.Bind(&o.Base, 3) + o.languageSetting = property.NewEnum[string]("LanguageSetting") + o.languageSetting.Bind(&o.Base, 4) + o.documentTemplate = property.NewByNameRef[element.Element]("DocumentTemplate", "DocumentTemplates$DocumentTemplate") + o.documentTemplate.Bind(&o.Base, 5) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 6) + o.overrideTopMargin = property.NewPrimitive[bool]("OverrideTopMargin", property.DecodeBool) + o.overrideTopMargin.Bind(&o.Base, 7) + o.overrideBottomMargin = property.NewPrimitive[bool]("OverrideBottomMargin", property.DecodeBool) + o.overrideBottomMargin.Bind(&o.Base, 8) + o.overrideLeftMargin = property.NewPrimitive[bool]("OverrideLeftMargin", property.DecodeBool) + o.overrideLeftMargin.Bind(&o.Base, 9) + o.overrideRightMargin = property.NewPrimitive[bool]("OverrideRightMargin", property.DecodeBool) + o.overrideRightMargin.Bind(&o.Base, 10) + o.marginLeftInInch = property.NewPrimitive[string]("MarginLeftInInch", property.DecodeString) + o.marginLeftInInch.Bind(&o.Base, 11) + o.marginLeftInInchModel = property.NewPart[element.Element]("MarginLeftInInchModel") + o.marginLeftInInchModel.Bind(&o.Base, 12) + o.marginRightInInch = property.NewPrimitive[string]("MarginRightInInch", property.DecodeString) + o.marginRightInInch.Bind(&o.Base, 13) + o.marginRightInInchModel = property.NewPart[element.Element]("MarginRightInInchModel") + o.marginRightInInchModel.Bind(&o.Base, 14) + o.marginTopInInch = property.NewPrimitive[string]("MarginTopInInch", property.DecodeString) + o.marginTopInInch.Bind(&o.Base, 15) + o.marginTopInInchModel = property.NewPart[element.Element]("MarginTopInInchModel") + o.marginTopInInchModel.Bind(&o.Base, 16) + o.marginBottomInInch = property.NewPrimitive[string]("MarginBottomInInch", property.DecodeString) + o.marginBottomInInch.Bind(&o.Base, 17) + o.marginBottomInInchModel = property.NewPart[element.Element]("MarginBottomInInchModel") + o.marginBottomInInchModel.Bind(&o.Base, 18) + o.SetProperties([]element.Property{o.errorHandlingType, o.fileVariableName, o.languageVariableName, o.documentType, o.languageSetting, o.documentTemplate, o.parameterMappings, o.overrideTopMargin, o.overrideBottomMargin, o.overrideLeftMargin, o.overrideRightMargin, o.marginLeftInInch, o.marginLeftInInchModel, o.marginRightInInch, o.marginRightInInchModel, o.marginTopInInch, o.marginTopInInchModel, o.marginBottomInInch, o.marginBottomInInchModel, }) + return o +} + +// NewGenerateDocumentAction creates a new GenerateDocumentAction for user code. Marked dirty (bit 63 = new element). +func NewGenerateDocumentAction() *GenerateDocumentAction { + o := initGenerateDocumentAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGenerateJumpToOptionsAction creates a GenerateJumpToOptionsAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGenerateJumpToOptionsAction() *GenerateJumpToOptionsAction { + o := &GenerateJumpToOptionsAction{} + o.SetTypeName("Microflows$GenerateJumpToOptionsAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 1) + o.workflow = property.NewByNameRef[element.Element]("Workflow", "Workflows$Workflow") + o.workflow.Bind(&o.Base, 2) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflowVariable, o.workflow, o.outputVariableName, }) + return o +} + +// NewGenerateJumpToOptionsAction creates a new GenerateJumpToOptionsAction for user code. Marked dirty (bit 63 = new element). +func NewGenerateJumpToOptionsAction() *GenerateJumpToOptionsAction { + o := initGenerateJumpToOptionsAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGetWorkflowActivityRecordsAction creates a GetWorkflowActivityRecordsAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGetWorkflowActivityRecordsAction() *GetWorkflowActivityRecordsAction { + o := &GetWorkflowActivityRecordsAction{} + o.SetTypeName("Microflows$GetWorkflowActivityRecordsAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 1) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflowVariable, o.outputVariableName, }) + return o +} + +// NewGetWorkflowActivityRecordsAction creates a new GetWorkflowActivityRecordsAction for user code. Marked dirty (bit 63 = new element). +func NewGetWorkflowActivityRecordsAction() *GetWorkflowActivityRecordsAction { + o := initGetWorkflowActivityRecordsAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGetWorkflowDataAction creates a GetWorkflowDataAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGetWorkflowDataAction() *GetWorkflowDataAction { + o := &GetWorkflowDataAction{} + o.SetTypeName("Microflows$GetWorkflowDataAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 1) + o.workflow = property.NewByNameRef[element.Element]("Workflow", "Workflows$Workflow") + o.workflow.Bind(&o.Base, 2) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflowVariable, o.workflow, o.outputVariableName, }) + return o +} + +// NewGetWorkflowDataAction creates a new GetWorkflowDataAction for user code. Marked dirty (bit 63 = new element). +func NewGetWorkflowDataAction() *GetWorkflowDataAction { + o := initGetWorkflowDataAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGetWorkflowsAction creates a GetWorkflowsAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGetWorkflowsAction() *GetWorkflowsAction { + o := &GetWorkflowsAction{} + o.SetTypeName("Microflows$GetWorkflowsAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflowContextVariableName = property.NewPrimitive[string]("WorkflowContextVariableName", property.DecodeString) + o.workflowContextVariableName.Bind(&o.Base, 1) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflowContextVariableName, o.outputVariableName, }) + return o +} + +// NewGetWorkflowsAction creates a new GetWorkflowsAction for user code. Marked dirty (bit 63 = new element). +func NewGetWorkflowsAction() *GetWorkflowsAction { + o := initGetWorkflowsAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initHead creates a Head with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initHead() *Head { + o := &Head{} + o.SetTypeName("Microflows$Head") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.listVariableName, }) + return o +} + +// NewHead creates a new Head for user code. Marked dirty (bit 63 = new element). +func NewHead() *Head { + o := initHead() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initHttpConfiguration creates a HttpConfiguration with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initHttpConfiguration() *HttpConfiguration { + o := &HttpConfiguration{} + o.SetTypeName("Microflows$HttpConfiguration") + o.overrideLocation = property.NewPrimitive[bool]("OverrideLocation", property.DecodeBool) + o.overrideLocation.Bind(&o.Base, 0) + o.customLocation = property.NewPrimitive[string]("CustomLocation", property.DecodeString) + o.customLocation.Bind(&o.Base, 1) + o.customLocationModel = property.NewPart[element.Element]("CustomLocationModel") + o.customLocationModel.Bind(&o.Base, 2) + o.customLocationTemplate = property.NewPart[element.Element]("CustomLocationTemplate") + o.customLocationTemplate.Bind(&o.Base, 3) + o.useAuthentication = property.NewPrimitive[bool]("UseAuthentication", property.DecodeBool) + o.useAuthentication.Bind(&o.Base, 4) + o.httpAuthenticationUserName = property.NewPrimitive[string]("HttpAuthenticationUserName", property.DecodeString) + o.httpAuthenticationUserName.Bind(&o.Base, 5) + o.username = property.NewPart[element.Element]("Username") + o.username.Bind(&o.Base, 6) + o.authenticationPassword = property.NewPrimitive[string]("AuthenticationPassword", property.DecodeString) + o.authenticationPassword.Bind(&o.Base, 7) + o.password = property.NewPart[element.Element]("Password") + o.password.Bind(&o.Base, 8) + o.headerEntries = property.NewPartList[element.Element]("HeaderEntries") + o.headerEntries.Bind(&o.Base, 9) + o.httpMethod = property.NewEnum[string]("HttpMethod") + o.httpMethod.Bind(&o.Base, 10) + o.newHttpMethod = property.NewEnum[string]("NewHttpMethod") + o.newHttpMethod.Bind(&o.Base, 11) + o.clientCertificate = property.NewPrimitive[string]("ClientCertificate", property.DecodeString) + o.clientCertificate.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.overrideLocation, o.customLocation, o.customLocationModel, o.customLocationTemplate, o.useAuthentication, o.httpAuthenticationUserName, o.username, o.authenticationPassword, o.password, o.headerEntries, o.httpMethod, o.newHttpMethod, o.clientCertificate, }) + return o +} + +// NewHttpConfiguration creates a new HttpConfiguration for user code. Marked dirty (bit 63 = new element). +func NewHttpConfiguration() *HttpConfiguration { + o := initHttpConfiguration() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initHttpHeaderEntry creates a HttpHeaderEntry with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initHttpHeaderEntry() *HttpHeaderEntry { + o := &HttpHeaderEntry{} + o.SetTypeName("Microflows$HttpHeaderEntry") + o.key = property.NewPrimitive[string]("Key", property.DecodeString) + o.key.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.valueModel = property.NewPart[element.Element]("ValueModel") + o.valueModel.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.key, o.value, o.valueModel, }) + return o +} + +// NewHttpHeaderEntry creates a new HttpHeaderEntry for user code. Marked dirty (bit 63 = new element). +func NewHttpHeaderEntry() *HttpHeaderEntry { + o := initHttpHeaderEntry() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImportMappingCall creates a ImportMappingCall with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportMappingCall() *ImportMappingCall { + o := &ImportMappingCall{} + o.SetTypeName("Microflows$ImportMappingCall") + o.mapping = property.NewByNameRef[element.Element]("Mapping", "ImportMappings$ImportMapping") + o.mapping.Bind(&o.Base, 0) + o.objectHandlingBackup = property.NewEnum[string]("ObjectHandlingBackup") + o.objectHandlingBackup.Bind(&o.Base, 1) + o.commit = property.NewEnum[string]("Commit") + o.commit.Bind(&o.Base, 2) + o.mappingArgumentVariableName = property.NewPrimitive[string]("MappingArgumentVariableName", property.DecodeString) + o.mappingArgumentVariableName.Bind(&o.Base, 3) + o.propRange = property.NewPart[element.Element]("Range") + o.propRange.Bind(&o.Base, 4) + o.contentType = property.NewEnum[string]("ContentType") + o.contentType.Bind(&o.Base, 5) + o.forceSingleOccurrence = property.NewPrimitive[bool]("ForceSingleOccurrence", property.DecodeBool) + o.forceSingleOccurrence.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.mapping, o.objectHandlingBackup, o.commit, o.mappingArgumentVariableName, o.propRange, o.contentType, o.forceSingleOccurrence, }) + return o +} + +// NewImportMappingCall creates a new ImportMappingCall for user code. Marked dirty (bit 63 = new element). +func NewImportMappingCall() *ImportMappingCall { + o := initImportMappingCall() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImportMappingJavaActionParameterValue creates a ImportMappingJavaActionParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportMappingJavaActionParameterValue() *ImportMappingJavaActionParameterValue { + o := &ImportMappingJavaActionParameterValue{} + o.SetTypeName("Microflows$ImportMappingJavaActionParameterValue") + o.importMapping = property.NewByNameRef[element.Element]("ImportMapping", "ImportMappings$ImportMapping") + o.importMapping.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.importMapping, }) + return o +} + +// NewImportMappingJavaActionParameterValue creates a new ImportMappingJavaActionParameterValue for user code. Marked dirty (bit 63 = new element). +func NewImportMappingJavaActionParameterValue() *ImportMappingJavaActionParameterValue { + o := initImportMappingJavaActionParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImportMappingParameterValue creates a ImportMappingParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportMappingParameterValue() *ImportMappingParameterValue { + o := &ImportMappingParameterValue{} + o.SetTypeName("Microflows$ImportMappingParameterValue") + o.importMapping = property.NewByNameRef[element.Element]("ImportMapping", "ImportMappings$ImportMapping") + o.importMapping.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.importMapping, }) + return o +} + +// NewImportMappingParameterValue creates a new ImportMappingParameterValue for user code. Marked dirty (bit 63 = new element). +func NewImportMappingParameterValue() *ImportMappingParameterValue { + o := initImportMappingParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImportXmlAction creates a ImportXmlAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportXmlAction() *ImportXmlAction { + o := &ImportXmlAction{} + o.SetTypeName("Microflows$ImportXmlAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.xmlDocumentVariableName = property.NewPrimitive[string]("XmlDocumentVariableName", property.DecodeString) + o.xmlDocumentVariableName.Bind(&o.Base, 1) + o.resultHandling = property.NewPart[element.Element]("ResultHandling") + o.resultHandling.Bind(&o.Base, 2) + o.isValidationRequired = property.NewPrimitive[bool]("IsValidationRequired", property.DecodeBool) + o.isValidationRequired.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.xmlDocumentVariableName, o.resultHandling, o.isValidationRequired, }) + return o +} + +// NewImportXmlAction creates a new ImportXmlAction for user code. Marked dirty (bit 63 = new element). +func NewImportXmlAction() *ImportXmlAction { + o := initImportXmlAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIncludedAssociation creates a IncludedAssociation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIncludedAssociation() *IncludedAssociation { + o := &IncludedAssociation{} + o.SetTypeName("Microflows$IncludedAssociation") + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 0) + o.isParent = property.NewPrimitive[bool]("IsParent", property.DecodeBool) + o.isParent.Bind(&o.Base, 1) + o.includedAssociations = property.NewPartList[element.Element]("IncludedAssociations") + o.includedAssociations.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.association, o.isParent, o.includedAssociations, }) + return o +} + +// NewIncludedAssociation creates a new IncludedAssociation for user code. Marked dirty (bit 63 = new element). +func NewIncludedAssociation() *IncludedAssociation { + o := initIncludedAssociation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIncrementCounterMeterAction creates a IncrementCounterMeterAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIncrementCounterMeterAction() *IncrementCounterMeterAction { + o := &IncrementCounterMeterAction{} + o.SetTypeName("Microflows$IncrementCounterMeterAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.tags = property.NewPartList[element.Element]("Tags") + o.tags.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.name, o.description, o.tags, }) + return o +} + +// NewIncrementCounterMeterAction creates a new IncrementCounterMeterAction for user code. Marked dirty (bit 63 = new element). +func NewIncrementCounterMeterAction() *IncrementCounterMeterAction { + o := initIncrementCounterMeterAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initInheritanceCase creates a InheritanceCase with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initInheritanceCase() *InheritanceCase { + o := &InheritanceCase{} + o.SetTypeName("Microflows$InheritanceCase") + o.value = property.NewByNameRef[element.Element]("Value", "DomainModels$Entity") + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value, }) + return o +} + +// NewInheritanceCase creates a new InheritanceCase for user code. Marked dirty (bit 63 = new element). +func NewInheritanceCase() *InheritanceCase { + o := initInheritanceCase() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initInheritanceSplit creates a InheritanceSplit with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initInheritanceSplit() *InheritanceSplit { + o := &InheritanceSplit{} + o.SetTypeName("Microflows$InheritanceSplit") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.splitVariableName = property.NewPrimitive[string]("SplitVariableName", property.DecodeString) + o.splitVariableName.Bind(&o.Base, 2) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 3) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, o.splitVariableName, o.caption, o.documentation, }) + return o +} + +// NewInheritanceSplit creates a new InheritanceSplit for user code. Marked dirty (bit 63 = new element). +func NewInheritanceSplit() *InheritanceSplit { + o := initInheritanceSplit() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIntersect creates a Intersect with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIntersect() *Intersect { + o := &Intersect{} + o.SetTypeName("Microflows$Intersect") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.secondListOrObjectVariableName = property.NewPrimitive[string]("SecondListOrObjectVariableName", property.DecodeString) + o.secondListOrObjectVariableName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.listVariableName, o.secondListOrObjectVariableName, }) + return o +} + +// NewIntersect creates a new Intersect for user code. Marked dirty (bit 63 = new element). +func NewIntersect() *Intersect { + o := initIntersect() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIterableList creates a IterableList with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIterableList() *IterableList { + o := &IterableList{} + o.SetTypeName("Microflows$IterableList") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.variableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.variableName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.listVariableName, o.variableName, }) + return o +} + +// NewIterableList creates a new IterableList for user code. Marked dirty (bit 63 = new element). +func NewIterableList() *IterableList { + o := initIterableList() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJavaActionCallAction creates a JavaActionCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJavaActionCallAction() *JavaActionCallAction { + o := &JavaActionCallAction{} + o.SetTypeName("Microflows$JavaActionCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.javaAction = property.NewByNameRef[element.Element]("JavaAction", "JavaActions$JavaAction") + o.javaAction.Bind(&o.Base, 1) + o.queueSettings = property.NewPart[element.Element]("QueueSettings") + o.queueSettings.Bind(&o.Base, 2) + o.queue = property.NewByNameRef[element.Element]("Queue", "Queues$Queue") + o.queue.Bind(&o.Base, 3) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 4) + o.useReturnVariable = property.NewPrimitive[bool]("UseReturnVariable", property.DecodeBool) + o.useReturnVariable.Bind(&o.Base, 5) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.errorHandlingType, o.javaAction, o.queueSettings, o.queue, o.parameterMappings, o.useReturnVariable, o.outputVariableName, }) + return o +} + +// NewJavaActionCallAction creates a new JavaActionCallAction for user code. Marked dirty (bit 63 = new element). +func NewJavaActionCallAction() *JavaActionCallAction { + o := initJavaActionCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJavaActionParameterMapping creates a JavaActionParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJavaActionParameterMapping() *JavaActionParameterMapping { + o := &JavaActionParameterMapping{} + o.SetTypeName("Microflows$JavaActionParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "JavaActions$JavaActionParameter") + o.parameter.Bind(&o.Base, 0) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 1) + o.value = property.NewPart[element.Element]("Value") + o.value.Bind(&o.Base, 2) + o.parameterValue = property.NewPart[element.Element]("ParameterValue") + o.parameterValue.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.parameter, o.argument, o.value, o.parameterValue, }) + return o +} + +// NewJavaActionParameterMapping creates a new JavaActionParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewJavaActionParameterMapping() *JavaActionParameterMapping { + o := initJavaActionParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJavaScriptActionCallAction creates a JavaScriptActionCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJavaScriptActionCallAction() *JavaScriptActionCallAction { + o := &JavaScriptActionCallAction{} + o.SetTypeName("Microflows$JavaScriptActionCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.javaScriptAction = property.NewByNameRef[element.Element]("JavaScriptAction", "JavaScriptActions$JavaScriptAction") + o.javaScriptAction.Bind(&o.Base, 1) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 2) + o.useReturnVariable = property.NewPrimitive[bool]("UseReturnVariable", property.DecodeBool) + o.useReturnVariable.Bind(&o.Base, 3) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.javaScriptAction, o.parameterMappings, o.useReturnVariable, o.outputVariableName, }) + return o +} + +// NewJavaScriptActionCallAction creates a new JavaScriptActionCallAction for user code. Marked dirty (bit 63 = new element). +func NewJavaScriptActionCallAction() *JavaScriptActionCallAction { + o := initJavaScriptActionCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJavaScriptActionParameterMapping creates a JavaScriptActionParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJavaScriptActionParameterMapping() *JavaScriptActionParameterMapping { + o := &JavaScriptActionParameterMapping{} + o.SetTypeName("Microflows$JavaScriptActionParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "JavaScriptActions$JavaScriptActionParameter") + o.parameter.Bind(&o.Base, 0) + o.parameterValue = property.NewPart[element.Element]("ParameterValue") + o.parameterValue.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameter, o.parameterValue, }) + return o +} + +// NewJavaScriptActionParameterMapping creates a new JavaScriptActionParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewJavaScriptActionParameterMapping() *JavaScriptActionParameterMapping { + o := initJavaScriptActionParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListEquals creates a ListEquals with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListEquals() *ListEquals { + o := &ListEquals{} + o.SetTypeName("Microflows$ListEquals") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.secondListOrObjectVariableName = property.NewPrimitive[string]("SecondListOrObjectVariableName", property.DecodeString) + o.secondListOrObjectVariableName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.listVariableName, o.secondListOrObjectVariableName, }) + return o +} + +// NewListEquals creates a new ListEquals for user code. Marked dirty (bit 63 = new element). +func NewListEquals() *ListEquals { + o := initListEquals() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListOperationAction creates a ListOperationAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListOperationAction() *ListOperationAction { + o := &ListOperationAction{} + o.SetTypeName("Microflows$ListOperationsAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.operation = property.NewPart[element.Element]("Operation") + o.operation.Bind(&o.Base, 1) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.operation, o.outputVariableName, }) + return o +} + +// NewListOperationAction creates a new ListOperationAction for user code. Marked dirty (bit 63 = new element). +func NewListOperationAction() *ListOperationAction { + o := initListOperationAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListRange creates a ListRange with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListRange() *ListRange { + o := &ListRange{} + o.SetTypeName("Microflows$ListRange") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.customRange = property.NewPart[element.Element]("CustomRange") + o.customRange.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.listVariableName, o.customRange, }) + return o +} + +// NewListRange creates a new ListRange for user code. Marked dirty (bit 63 = new element). +func NewListRange() *ListRange { + o := initListRange() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLockWorkflowAction creates a LockWorkflowAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLockWorkflowAction() *LockWorkflowAction { + o := &LockWorkflowAction{} + o.SetTypeName("Microflows$LockWorkflowAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflow = property.NewByNameRef[element.Element]("Workflow", "Workflows$Workflow") + o.workflow.Bind(&o.Base, 1) + o.workflowSelection = property.NewPart[element.Element]("WorkflowSelection") + o.workflowSelection.Bind(&o.Base, 2) + o.pauseAllWorkflows = property.NewPrimitive[bool]("PauseAllWorkflows", property.DecodeBool) + o.pauseAllWorkflows.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflow, o.workflowSelection, o.pauseAllWorkflows, }) + return o +} + +// NewLockWorkflowAction creates a new LockWorkflowAction for user code. Marked dirty (bit 63 = new element). +func NewLockWorkflowAction() *LockWorkflowAction { + o := initLockWorkflowAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLogMessageAction creates a LogMessageAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLogMessageAction() *LogMessageAction { + o := &LogMessageAction{} + o.SetTypeName("Microflows$LogMessageAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.level = property.NewEnum[string]("Level") + o.level.Bind(&o.Base, 1) + o.node = property.NewPrimitive[string]("Node", property.DecodeString) + o.node.Bind(&o.Base, 2) + o.nodeModel = property.NewPart[element.Element]("NodeModel") + o.nodeModel.Bind(&o.Base, 3) + o.messageTemplate = property.NewPart[element.Element]("MessageTemplate") + o.messageTemplate.Bind(&o.Base, 4) + o.includeLatestStackTrace = property.NewPrimitive[bool]("IncludeLatestStackTrace", property.DecodeBool) + o.includeLatestStackTrace.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.errorHandlingType, o.level, o.node, o.nodeModel, o.messageTemplate, o.includeLatestStackTrace, }) + return o +} + +// NewLogMessageAction creates a new LogMessageAction for user code. Marked dirty (bit 63 = new element). +func NewLogMessageAction() *LogMessageAction { + o := initLogMessageAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLoopedActivity creates a LoopedActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLoopedActivity() *LoopedActivity { + o := &LoopedActivity{} + o.SetTypeName("Microflows$LoopedActivity") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.objectCollection = property.NewPart[element.Element]("ObjectCollection") + o.objectCollection.Bind(&o.Base, 2) + o.iteratedListVariableName = property.NewPrimitive[string]("IteratedListVariableName", property.DecodeString) + o.iteratedListVariableName.Bind(&o.Base, 3) + o.loopVariableName = property.NewPrimitive[string]("LoopVariableName", property.DecodeString) + o.loopVariableName.Bind(&o.Base, 4) + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 5) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 6) + o.loopSource = property.NewPart[element.Element]("LoopSource") + o.loopSource.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, o.objectCollection, o.iteratedListVariableName, o.loopVariableName, o.errorHandlingType, o.documentation, o.loopSource, }) + return o +} + +// NewLoopedActivity creates a new LoopedActivity for user code. Marked dirty (bit 63 = new element). +func NewLoopedActivity() *LoopedActivity { + o := initLoopedActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMLModelCall creates a MLModelCall with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMLModelCall() *MLModelCall { + o := &MLModelCall{} + o.SetTypeName("Microflows$MLModelCall") + o.modelReference = property.NewPrimitive[string]("ModelReference", property.DecodeString) + o.modelReference.Bind(&o.Base, 0) + o.mlMappingDocument = property.NewByNameRef[element.Element]("MlMappingDocument", "MLMappings$MLMappingDocument") + o.mlMappingDocument.Bind(&o.Base, 1) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.modelReference, o.mlMappingDocument, o.parameterMappings, }) + return o +} + +// NewMLModelCall creates a new MLModelCall for user code. Marked dirty (bit 63 = new element). +func NewMLModelCall() *MLModelCall { + o := initMLModelCall() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMLModelCallAction creates a MLModelCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMLModelCallAction() *MLModelCallAction { + o := &MLModelCallAction{} + o.SetTypeName("Microflows$MLModelCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.modelCall = property.NewPart[element.Element]("ModelCall") + o.modelCall.Bind(&o.Base, 1) + o.mlMappingDocument = property.NewByNameRef[element.Element]("MlMappingDocument", "MLMappings$MLMappingDocument") + o.mlMappingDocument.Bind(&o.Base, 2) + o.inputVariableName = property.NewPrimitive[string]("InputVariableName", property.DecodeString) + o.inputVariableName.Bind(&o.Base, 3) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.modelCall, o.mlMappingDocument, o.inputVariableName, o.outputVariableName, }) + return o +} + +// NewMLModelCallAction creates a new MLModelCallAction for user code. Marked dirty (bit 63 = new element). +func NewMLModelCallAction() *MLModelCallAction { + o := initMLModelCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMLModelCallParameterMapping creates a MLModelCallParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMLModelCallParameterMapping() *MLModelCallParameterMapping { + o := &MLModelCallParameterMapping{} + o.SetTypeName("Microflows$MLModelCallParameterMapping") + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 0) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 1) + o.initialValue = property.NewPrimitive[string]("InitialValue", property.DecodeString) + o.initialValue.Bind(&o.Base, 2) + o.initialValueModel = property.NewPrimitive[string]("InitialValueModel", property.DecodeString) + o.initialValueModel.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.parameterName, o.parameterType, o.initialValue, o.initialValueModel, }) + return o +} + +// NewMLModelCallParameterMapping creates a new MLModelCallParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewMLModelCallParameterMapping() *MLModelCallParameterMapping { + o := initMLModelCallParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMappingRequestHandling creates a MappingRequestHandling with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMappingRequestHandling() *MappingRequestHandling { + o := &MappingRequestHandling{} + o.SetTypeName("Microflows$MappingRequestHandling") + o.mapping = property.NewByNameRef[element.Element]("Mapping", "ExportMappings$ExportMapping") + o.mapping.Bind(&o.Base, 0) + o.mappingArgumentVariableName = property.NewPrimitive[string]("MappingArgumentVariableName", property.DecodeString) + o.mappingArgumentVariableName.Bind(&o.Base, 1) + o.contentType = property.NewEnum[string]("ContentType") + o.contentType.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.mapping, o.mappingArgumentVariableName, o.contentType, }) + return o +} + +// NewMappingRequestHandling creates a new MappingRequestHandling for user code. Marked dirty (bit 63 = new element). +func NewMappingRequestHandling() *MappingRequestHandling { + o := initMappingRequestHandling() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMemberChange creates a MemberChange with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMemberChange() *MemberChange { + o := &MemberChange{} + o.SetTypeName("Microflows$ChangeActionItem") + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 0) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 1) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 2) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 3) + o.valueModel = property.NewPart[element.Element]("ValueModel") + o.valueModel.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.attribute, o.association, o.propType, o.value, o.valueModel, }) + return o +} + +// NewMemberChange creates a new MemberChange for user code. Marked dirty (bit 63 = new element). +func NewMemberChange() *MemberChange { + o := initMemberChange() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMeterTagMapping creates a MeterTagMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMeterTagMapping() *MeterTagMapping { + o := &MeterTagMapping{} + o.SetTypeName("Microflows$MeterTagMapping") + o.key = property.NewPrimitive[string]("Key", property.DecodeString) + o.key.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.key, o.value, }) + return o +} + +// NewMeterTagMapping creates a new MeterTagMapping for user code. Marked dirty (bit 63 = new element). +func NewMeterTagMapping() *MeterTagMapping { + o := initMeterTagMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflow creates a Microflow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflow() *Microflow { + o := &Microflow{} + o.SetTypeName("Microflows$Microflow") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.objectCollection = property.NewPart[element.Element]("ObjectCollection") + o.objectCollection.Bind(&o.Base, 4) + o.flows = property.NewPartList[element.Element]("Flows") + o.flows.Bind(&o.Base, 5) + o.returnType = property.NewPrimitive[string]("ReturnType", property.DecodeString) + o.returnType.Bind(&o.Base, 6) + o.microflowReturnType = property.NewPart[element.Element]("MicroflowReturnType") + o.microflowReturnType.Bind(&o.Base, 7) + o.markAsUsed = property.NewPrimitive[bool]("MarkAsUsed", property.DecodeBool) + o.markAsUsed.Bind(&o.Base, 8) + o.returnVariableName = property.NewPrimitive[string]("ReturnVariableName", property.DecodeString) + o.returnVariableName.Bind(&o.Base, 9) + o.applyEntityAccess = property.NewPrimitive[bool]("ApplyEntityAccess", property.DecodeBool) + o.applyEntityAccess.Bind(&o.Base, 10) + o.allowedModuleRoles = property.NewByNameRefList[element.Element]("AllowedModuleRoles", "Security$ModuleRole") + o.allowedModuleRoles.Bind(&o.Base, 11) + o.microflowActionInfo = property.NewPart[element.Element]("MicroflowActionInfo") + o.microflowActionInfo.Bind(&o.Base, 12) + o.workflowActionInfo = property.NewPart[element.Element]("WorkflowActionInfo") + o.workflowActionInfo.Bind(&o.Base, 13) + o.allowConcurrentExecution = property.NewPrimitive[bool]("AllowConcurrentExecution", property.DecodeBool) + o.allowConcurrentExecution.Bind(&o.Base, 14) + o.concurrencyErrorMessage = property.NewPart[element.Element]("ConcurrencyErrorMessage") + o.concurrencyErrorMessage.Bind(&o.Base, 15) + o.concurrencyErrorMicroflow = property.NewByNameRef[element.Element]("ConcurrencyErrorMicroflow", "Microflows$Microflow") + o.concurrencyErrorMicroflow.Bind(&o.Base, 16) + o.url = property.NewPrimitive[string]("Url", property.DecodeString) + o.url.Bind(&o.Base, 17) + o.urlSearchParameters = property.NewByNameRefList[element.Element]("UrlSearchParameters", "Microflows$MicroflowParameter") + o.urlSearchParameters.Bind(&o.Base, 18) + o.stableId = property.NewPrimitive[string]("StableId", property.DecodeString) + o.stableId.Bind(&o.Base, 19) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.objectCollection, o.flows, o.returnType, o.microflowReturnType, o.markAsUsed, o.returnVariableName, o.applyEntityAccess, o.allowedModuleRoles, o.microflowActionInfo, o.workflowActionInfo, o.allowConcurrentExecution, o.concurrencyErrorMessage, o.concurrencyErrorMicroflow, o.url, o.urlSearchParameters, o.stableId, }) + return o +} + +// NewMicroflow creates a new Microflow for user code. Marked dirty (bit 63 = new element). +func NewMicroflow() *Microflow { + o := initMicroflow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowCall creates a MicroflowCall with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowCall() *MicroflowCall { + o := &MicroflowCall{} + o.SetTypeName("Microflows$MicroflowCall") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.queueSettings = property.NewPart[element.Element]("QueueSettings") + o.queueSettings.Bind(&o.Base, 1) + o.queue = property.NewByNameRef[element.Element]("Queue", "Queues$Queue") + o.queue.Bind(&o.Base, 2) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.microflow, o.queueSettings, o.queue, o.parameterMappings, }) + return o +} + +// NewMicroflowCall creates a new MicroflowCall for user code. Marked dirty (bit 63 = new element). +func NewMicroflowCall() *MicroflowCall { + o := initMicroflowCall() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowCallAction creates a MicroflowCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowCallAction() *MicroflowCallAction { + o := &MicroflowCallAction{} + o.SetTypeName("Microflows$MicroflowCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.microflowCall = property.NewPart[element.Element]("MicroflowCall") + o.microflowCall.Bind(&o.Base, 1) + o.useReturnVariable = property.NewPrimitive[bool]("UseReturnVariable", property.DecodeBool) + o.useReturnVariable.Bind(&o.Base, 2) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.microflowCall, o.useReturnVariable, o.outputVariableName, }) + return o +} + +// NewMicroflowCallAction creates a new MicroflowCallAction for user code. Marked dirty (bit 63 = new element). +func NewMicroflowCallAction() *MicroflowCallAction { + o := initMicroflowCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowCallParameterMapping creates a MicroflowCallParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowCallParameterMapping() *MicroflowCallParameterMapping { + o := &MicroflowCallParameterMapping{} + o.SetTypeName("Mappings$MicroflowCallParameterMappingImpl") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Microflows$MicroflowParameter") + o.parameter.Bind(&o.Base, 0) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 1) + o.argumentModel = property.NewPart[element.Element]("ArgumentModel") + o.argumentModel.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.parameter, o.argument, o.argumentModel, }) + return o +} + +// NewMicroflowCallParameterMapping creates a new MicroflowCallParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewMicroflowCallParameterMapping() *MicroflowCallParameterMapping { + o := initMicroflowCallParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowJavaActionParameterValue creates a MicroflowJavaActionParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowJavaActionParameterValue() *MicroflowJavaActionParameterValue { + o := &MicroflowJavaActionParameterValue{} + o.SetTypeName("Microflows$MicroflowJavaActionParameterValue") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow, }) + return o +} + +// NewMicroflowJavaActionParameterValue creates a new MicroflowJavaActionParameterValue for user code. Marked dirty (bit 63 = new element). +func NewMicroflowJavaActionParameterValue() *MicroflowJavaActionParameterValue { + o := initMicroflowJavaActionParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowObjectCollection creates a MicroflowObjectCollection with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowObjectCollection() *MicroflowObjectCollection { + o := &MicroflowObjectCollection{} + o.SetTypeName("Microflows$MicroflowObjectCollection") + o.objects = property.NewPartList[element.Element]("Objects") + o.objects.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.objects, }) + return o +} + +// NewMicroflowObjectCollection creates a new MicroflowObjectCollection for user code. Marked dirty (bit 63 = new element). +func NewMicroflowObjectCollection() *MicroflowObjectCollection { + o := initMicroflowObjectCollection() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowParameter creates a MicroflowParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowParameter() *MicroflowParameter { + o := &MicroflowParameter{} + o.SetTypeName("Microflows$MicroflowParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 1) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.propType, o.parameterType, }) + return o +} + +// NewMicroflowParameter creates a new MicroflowParameter for user code. Marked dirty (bit 63 = new element). +func NewMicroflowParameter() *MicroflowParameter { + o := initMicroflowParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowParameterAttributeUrlSegment creates a MicroflowParameterAttributeUrlSegment with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowParameterAttributeUrlSegment() *MicroflowParameterAttributeUrlSegment { + o := &MicroflowParameterAttributeUrlSegment{} + o.SetTypeName("Microflows$MicroflowParameterAttributeUrlSegment") + o.microflowParameter = property.NewByNameRef[element.Element]("MicroflowParameter", "Microflows$MicroflowParameter") + o.microflowParameter.Bind(&o.Base, 0) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.microflowParameter, o.attribute, }) + return o +} + +// NewMicroflowParameterAttributeUrlSegment creates a new MicroflowParameterAttributeUrlSegment for user code. Marked dirty (bit 63 = new element). +func NewMicroflowParameterAttributeUrlSegment() *MicroflowParameterAttributeUrlSegment { + o := initMicroflowParameterAttributeUrlSegment() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowParameterObject creates a MicroflowParameterObject with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowParameterObject() *MicroflowParameterObject { + o := &MicroflowParameterObject{} + o.SetTypeName("Microflows$MicroflowParameterObject") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 2) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 3) + o.variableType = property.NewPart[element.Element]("VariableType") + o.variableType.Bind(&o.Base, 4) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 5) + o.hasVariableNameBeenChanged = property.NewPrimitive[bool]("HasVariableNameBeenChanged", property.DecodeBool) + o.hasVariableNameBeenChanged.Bind(&o.Base, 6) + o.isRequired = property.NewPrimitive[bool]("IsRequired", property.DecodeBool) + o.isRequired.Bind(&o.Base, 7) + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, o.name, o.propType, o.variableType, o.documentation, o.hasVariableNameBeenChanged, o.isRequired, o.defaultValue, }) + return o +} + +// NewMicroflowParameterObject creates a new MicroflowParameterObject for user code. Marked dirty (bit 63 = new element). +func NewMicroflowParameterObject() *MicroflowParameterObject { + o := initMicroflowParameterObject() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowParameterValue creates a MicroflowParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowParameterValue() *MicroflowParameterValue { + o := &MicroflowParameterValue{} + o.SetTypeName("Microflows$MicroflowParameterValue") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow, }) + return o +} + +// NewMicroflowParameterValue creates a new MicroflowParameterValue for user code. Marked dirty (bit 63 = new element). +func NewMicroflowParameterValue() *MicroflowParameterValue { + o := initMicroflowParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowPrimitiveParameterUrlSegment creates a MicroflowPrimitiveParameterUrlSegment with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowPrimitiveParameterUrlSegment() *MicroflowPrimitiveParameterUrlSegment { + o := &MicroflowPrimitiveParameterUrlSegment{} + o.SetTypeName("Microflows$MicroflowPrimitiveParameterUrlSegment") + o.microflowParameter = property.NewByNameRef[element.Element]("MicroflowParameter", "Microflows$MicroflowParameter") + o.microflowParameter.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflowParameter, }) + return o +} + +// NewMicroflowPrimitiveParameterUrlSegment creates a new MicroflowPrimitiveParameterUrlSegment for user code. Marked dirty (bit 63 = new element). +func NewMicroflowPrimitiveParameterUrlSegment() *MicroflowPrimitiveParameterUrlSegment { + o := initMicroflowPrimitiveParameterUrlSegment() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNanoflow creates a Nanoflow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNanoflow() *Nanoflow { + o := &Nanoflow{} + o.SetTypeName("Microflows$Nanoflow") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.objectCollection = property.NewPart[element.Element]("ObjectCollection") + o.objectCollection.Bind(&o.Base, 4) + o.flows = property.NewPartList[element.Element]("Flows") + o.flows.Bind(&o.Base, 5) + o.returnType = property.NewPrimitive[string]("ReturnType", property.DecodeString) + o.returnType.Bind(&o.Base, 6) + o.microflowReturnType = property.NewPart[element.Element]("MicroflowReturnType") + o.microflowReturnType.Bind(&o.Base, 7) + o.markAsUsed = property.NewPrimitive[bool]("MarkAsUsed", property.DecodeBool) + o.markAsUsed.Bind(&o.Base, 8) + o.returnVariableName = property.NewPrimitive[string]("ReturnVariableName", property.DecodeString) + o.returnVariableName.Bind(&o.Base, 9) + o.allowedModuleRoles = property.NewByNameRefList[element.Element]("AllowedModuleRoles", "Security$ModuleRole") + o.allowedModuleRoles.Bind(&o.Base, 10) + o.useListParameterByReference = property.NewPrimitive[bool]("UseListParameterByReference", property.DecodeBool) + o.useListParameterByReference.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.objectCollection, o.flows, o.returnType, o.microflowReturnType, o.markAsUsed, o.returnVariableName, o.allowedModuleRoles, o.useListParameterByReference, }) + return o +} + +// NewNanoflow creates a new Nanoflow for user code. Marked dirty (bit 63 = new element). +func NewNanoflow() *Nanoflow { + o := initNanoflow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNanoflowCall creates a NanoflowCall with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNanoflowCall() *NanoflowCall { + o := &NanoflowCall{} + o.SetTypeName("Microflows$NanoflowCall") + o.nanoflow = property.NewByNameRef[element.Element]("Nanoflow", "Microflows$Nanoflow") + o.nanoflow.Bind(&o.Base, 0) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.nanoflow, o.parameterMappings, }) + return o +} + +// NewNanoflowCall creates a new NanoflowCall for user code. Marked dirty (bit 63 = new element). +func NewNanoflowCall() *NanoflowCall { + o := initNanoflowCall() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNanoflowCallAction creates a NanoflowCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNanoflowCallAction() *NanoflowCallAction { + o := &NanoflowCallAction{} + o.SetTypeName("Microflows$NanoflowCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.nanoflowCall = property.NewPart[element.Element]("NanoflowCall") + o.nanoflowCall.Bind(&o.Base, 1) + o.useReturnVariable = property.NewPrimitive[bool]("UseReturnVariable", property.DecodeBool) + o.useReturnVariable.Bind(&o.Base, 2) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.nanoflowCall, o.useReturnVariable, o.outputVariableName, }) + return o +} + +// NewNanoflowCallAction creates a new NanoflowCallAction for user code. Marked dirty (bit 63 = new element). +func NewNanoflowCallAction() *NanoflowCallAction { + o := initNanoflowCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNanoflowCallParameterMapping creates a NanoflowCallParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNanoflowCallParameterMapping() *NanoflowCallParameterMapping { + o := &NanoflowCallParameterMapping{} + o.SetTypeName("Microflows$NanoflowCallParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Microflows$NanoflowParameter") + o.parameter.Bind(&o.Base, 0) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 1) + o.argumentModel = property.NewPart[element.Element]("ArgumentModel") + o.argumentModel.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.parameter, o.argument, o.argumentModel, }) + return o +} + +// NewNanoflowCallParameterMapping creates a new NanoflowCallParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewNanoflowCallParameterMapping() *NanoflowCallParameterMapping { + o := initNanoflowCallParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNanoflowParameter creates a NanoflowParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNanoflowParameter() *NanoflowParameter { + o := &NanoflowParameter{} + o.SetTypeName("Microflows$NanoflowParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 1) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.propType, o.parameterType, }) + return o +} + +// NewNanoflowParameter creates a new NanoflowParameter for user code. Marked dirty (bit 63 = new element). +func NewNanoflowParameter() *NanoflowParameter { + o := initNanoflowParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNoCase creates a NoCase with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNoCase() *NoCase { + o := &NoCase{} + o.SetTypeName("Microflows$NoCase") + o.SetProperties([]element.Property{}) + return o +} + +// NewNoCase creates a new NoCase for user code. Marked dirty (bit 63 = new element). +func NewNoCase() *NoCase { + o := initNoCase() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNotifyWorkflowAction creates a NotifyWorkflowAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNotifyWorkflowAction() *NotifyWorkflowAction { + o := &NotifyWorkflowAction{} + o.SetTypeName("Microflows$NotifyWorkflowAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 1) + o.activity = property.NewByNameRef[element.Element]("Activity", "Workflows$WaitForNotificationActivity") + o.activity.Bind(&o.Base, 2) + o.notifyTarget = property.NewPart[element.Element]("NotifyTarget") + o.notifyTarget.Bind(&o.Base, 3) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflowVariable, o.activity, o.notifyTarget, o.outputVariableName, }) + return o +} + +// NewNotifyWorkflowAction creates a new NotifyWorkflowAction for user code. Marked dirty (bit 63 = new element). +func NewNotifyWorkflowAction() *NotifyWorkflowAction { + o := initNotifyWorkflowAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOpenUserTaskAction creates a OpenUserTaskAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOpenUserTaskAction() *OpenUserTaskAction { + o := &OpenUserTaskAction{} + o.SetTypeName("Microflows$OpenUserTaskAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.userTaskVariable = property.NewPrimitive[string]("UserTaskVariable", property.DecodeString) + o.userTaskVariable.Bind(&o.Base, 1) + o.assignOnOpen = property.NewPrimitive[bool]("AssignOnOpen", property.DecodeBool) + o.assignOnOpen.Bind(&o.Base, 2) + o.openWhenAssigned = property.NewPrimitive[bool]("OpenWhenAssigned", property.DecodeBool) + o.openWhenAssigned.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.userTaskVariable, o.assignOnOpen, o.openWhenAssigned, }) + return o +} + +// NewOpenUserTaskAction creates a new OpenUserTaskAction for user code. Marked dirty (bit 63 = new element). +func NewOpenUserTaskAction() *OpenUserTaskAction { + o := initOpenUserTaskAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOpenWorkflowAction creates a OpenWorkflowAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOpenWorkflowAction() *OpenWorkflowAction { + o := &OpenWorkflowAction{} + o.SetTypeName("Microflows$OpenWorkflowAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflowVariable, }) + return o +} + +// NewOpenWorkflowAction creates a new OpenWorkflowAction for user code. Marked dirty (bit 63 = new element). +func NewOpenWorkflowAction() *OpenWorkflowAction { + o := initOpenWorkflowAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOrthogonalPath creates a OrthogonalPath with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOrthogonalPath() *OrthogonalPath { + o := &OrthogonalPath{} + o.SetTypeName("Microflows$OrthogonalPath") + o.segmentPositions = property.NewPrimitive[string]("SegmentPositions", property.DecodeString) + o.segmentPositions.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.segmentPositions, }) + return o +} + +// NewOrthogonalPath creates a new OrthogonalPath for user code. Marked dirty (bit 63 = new element). +func NewOrthogonalPath() *OrthogonalPath { + o := initOrthogonalPath() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOutputVariable creates a OutputVariable with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOutputVariable() *OutputVariable { + o := &OutputVariable{} + o.SetTypeName("Microflows$OutputVariable") + o.variableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.variableName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.variableName, }) + return o +} + +// NewOutputVariable creates a new OutputVariable for user code. Marked dirty (bit 63 = new element). +func NewOutputVariable() *OutputVariable { + o := initOutputVariable() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initParameterIdUrlSegment creates a ParameterIdUrlSegment with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initParameterIdUrlSegment() *ParameterIdUrlSegment { + o := &ParameterIdUrlSegment{} + o.SetTypeName("Microflows$ParameterIdUrlSegment") + o.microflowParameter = property.NewByNameRef[element.Element]("MicroflowParameter", "Microflows$MicroflowParameter") + o.microflowParameter.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflowParameter, }) + return o +} + +// NewParameterIdUrlSegment creates a new ParameterIdUrlSegment for user code. Marked dirty (bit 63 = new element). +func NewParameterIdUrlSegment() *ParameterIdUrlSegment { + o := initParameterIdUrlSegment() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPauseOperation creates a PauseOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPauseOperation() *PauseOperation { + o := &PauseOperation{} + o.SetTypeName("Microflows$PauseOperation") + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.workflowVariable, }) + return o +} + +// NewPauseOperation creates a new PauseOperation for user code. Marked dirty (bit 63 = new element). +func NewPauseOperation() *PauseOperation { + o := initPauseOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPrimitiveTypedTemplateArgument creates a PrimitiveTypedTemplateArgument with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPrimitiveTypedTemplateArgument() *PrimitiveTypedTemplateArgument { + o := &PrimitiveTypedTemplateArgument{} + o.SetTypeName("Microflows$PrimitiveTypedTemplateArgument") + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 0) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.expression, o.propType, }) + return o +} + +// NewPrimitiveTypedTemplateArgument creates a new PrimitiveTypedTemplateArgument for user code. Marked dirty (bit 63 = new element). +func NewPrimitiveTypedTemplateArgument() *PrimitiveTypedTemplateArgument { + o := initPrimitiveTypedTemplateArgument() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initProxyConfiguration creates a ProxyConfiguration with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initProxyConfiguration() *ProxyConfiguration { + o := &ProxyConfiguration{} + o.SetTypeName("Microflows$ProxyConfiguration") + o.usernameExpression = property.NewPrimitive[string]("UsernameExpression", property.DecodeString) + o.usernameExpression.Bind(&o.Base, 0) + o.usernameExpressionModel = property.NewPart[element.Element]("UsernameExpressionModel") + o.usernameExpressionModel.Bind(&o.Base, 1) + o.passwordExpression = property.NewPrimitive[string]("PasswordExpression", property.DecodeString) + o.passwordExpression.Bind(&o.Base, 2) + o.passwordExpressionModel = property.NewPart[element.Element]("PasswordExpressionModel") + o.passwordExpressionModel.Bind(&o.Base, 3) + o.hostExpression = property.NewPrimitive[string]("HostExpression", property.DecodeString) + o.hostExpression.Bind(&o.Base, 4) + o.hostExpressionModel = property.NewPart[element.Element]("HostExpressionModel") + o.hostExpressionModel.Bind(&o.Base, 5) + o.portExpression = property.NewPrimitive[string]("PortExpression", property.DecodeString) + o.portExpression.Bind(&o.Base, 6) + o.portExpressionModel = property.NewPart[element.Element]("PortExpressionModel") + o.portExpressionModel.Bind(&o.Base, 7) + o.useConfigurationExpression = property.NewPrimitive[string]("UseConfigurationExpression", property.DecodeString) + o.useConfigurationExpression.Bind(&o.Base, 8) + o.useConfigurationExpressionModel = property.NewPart[element.Element]("UseConfigurationExpressionModel") + o.useConfigurationExpressionModel.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.usernameExpression, o.usernameExpressionModel, o.passwordExpression, o.passwordExpressionModel, o.hostExpression, o.hostExpressionModel, o.portExpression, o.portExpressionModel, o.useConfigurationExpression, o.useConfigurationExpressionModel, }) + return o +} + +// NewProxyConfiguration creates a new ProxyConfiguration for user code. Marked dirty (bit 63 = new element). +func NewProxyConfiguration() *ProxyConfiguration { + o := initProxyConfiguration() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPushToClientAction creates a PushToClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPushToClientAction() *PushToClientAction { + o := &PushToClientAction{} + o.SetTypeName("Microflows$PushToClientAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.dataVariableName = property.NewPrimitive[string]("DataVariableName", property.DecodeString) + o.dataVariableName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.errorHandlingType, o.dataVariableName, }) + return o +} + +// NewPushToClientAction creates a new PushToClientAction for user code. Marked dirty (bit 63 = new element). +func NewPushToClientAction() *PushToClientAction { + o := initPushToClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initQueryParameterMapping creates a QueryParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initQueryParameterMapping() *QueryParameterMapping { + o := &QueryParameterMapping{} + o.SetTypeName("Microflows$QueryParameterMapping") + o.queryParameter = property.NewByNameRef[element.Element]("QueryParameter", "Rest$QueryParameter") + o.queryParameter.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.included = property.NewEnum[string]("Included") + o.included.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.queryParameter, o.value, o.included, }) + return o +} + +// NewQueryParameterMapping creates a new QueryParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewQueryParameterMapping() *QueryParameterMapping { + o := initQueryParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestCallAction creates a RestCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestCallAction() *RestCallAction { + o := &RestCallAction{} + o.SetTypeName("Microflows$RestCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.httpConfiguration = property.NewPart[element.Element]("HttpConfiguration") + o.httpConfiguration.Bind(&o.Base, 1) + o.requestHandling = property.NewPart[element.Element]("RequestHandling") + o.requestHandling.Bind(&o.Base, 2) + o.requestHandlingType = property.NewEnum[string]("RequestHandlingType") + o.requestHandlingType.Bind(&o.Base, 3) + o.resultHandling = property.NewPart[element.Element]("ResultHandling") + o.resultHandling.Bind(&o.Base, 4) + o.resultHandlingType = property.NewEnum[string]("ResultHandlingType") + o.resultHandlingType.Bind(&o.Base, 5) + o.errorResultHandlingType = property.NewEnum[string]("ErrorResultHandlingType") + o.errorResultHandlingType.Bind(&o.Base, 6) + o.useRequestTimeOut = property.NewPrimitive[bool]("UseRequestTimeOut", property.DecodeBool) + o.useRequestTimeOut.Bind(&o.Base, 7) + o.timeOut = property.NewPrimitive[int32]("TimeOut", property.DecodeInt32) + o.timeOut.Bind(&o.Base, 8) + o.timeOutModel = property.NewPart[element.Element]("TimeOutModel") + o.timeOutModel.Bind(&o.Base, 9) + o.timeOutExpression = property.NewPrimitive[string]("TimeOutExpression", property.DecodeString) + o.timeOutExpression.Bind(&o.Base, 10) + o.requestProxyType = property.NewEnum[string]("RequestProxyType") + o.requestProxyType.Bind(&o.Base, 11) + o.proxyConfiguration = property.NewPart[element.Element]("ProxyConfiguration") + o.proxyConfiguration.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.errorHandlingType, o.httpConfiguration, o.requestHandling, o.requestHandlingType, o.resultHandling, o.resultHandlingType, o.errorResultHandlingType, o.useRequestTimeOut, o.timeOut, o.timeOutModel, o.timeOutExpression, o.requestProxyType, o.proxyConfiguration, }) + return o +} + +// NewRestCallAction creates a new RestCallAction for user code. Marked dirty (bit 63 = new element). +func NewRestCallAction() *RestCallAction { + o := initRestCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestOperationCallAction creates a RestOperationCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestOperationCallAction() *RestOperationCallAction { + o := &RestOperationCallAction{} + o.SetTypeName("Microflows$RestOperationCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.operation = property.NewByNameRef[element.Element]("Operation", "Rest$RestOperation") + o.operation.Bind(&o.Base, 1) + o.baseUrlParameterMapping = property.NewPart[element.Element]("BaseUrlParameterMapping") + o.baseUrlParameterMapping.Bind(&o.Base, 2) + o.bodyVariable = property.NewPart[element.Element]("BodyVariable") + o.bodyVariable.Bind(&o.Base, 3) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 4) + o.queryParameterMappings = property.NewPartList[element.Element]("QueryParameterMappings") + o.queryParameterMappings.Bind(&o.Base, 5) + o.outputVariable = property.NewPart[element.Element]("OutputVariable") + o.outputVariable.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.errorHandlingType, o.operation, o.baseUrlParameterMapping, o.bodyVariable, o.parameterMappings, o.queryParameterMappings, o.outputVariable, }) + return o +} + +// NewRestOperationCallAction creates a new RestOperationCallAction for user code. Marked dirty (bit 63 = new element). +func NewRestOperationCallAction() *RestOperationCallAction { + o := initRestOperationCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestOperationParameterMapping creates a RestOperationParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestOperationParameterMapping() *RestOperationParameterMapping { + o := &RestOperationParameterMapping{} + o.SetTypeName("Microflows$RestOperationParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Rest$OperationParameter") + o.parameter.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameter, o.value, }) + return o +} + +// NewRestOperationParameterMapping creates a new RestOperationParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewRestOperationParameterMapping() *RestOperationParameterMapping { + o := initRestOperationParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestParameterMapping creates a RestParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestParameterMapping() *RestParameterMapping { + o := &RestParameterMapping{} + o.SetTypeName("Microflows$RestParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Rest$RestParameter") + o.parameter.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameter, o.value, }) + return o +} + +// NewRestParameterMapping creates a new RestParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewRestParameterMapping() *RestParameterMapping { + o := initRestParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestartOperation creates a RestartOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestartOperation() *RestartOperation { + o := &RestartOperation{} + o.SetTypeName("Microflows$RestartOperation") + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.workflowVariable, }) + return o +} + +// NewRestartOperation creates a new RestartOperation for user code. Marked dirty (bit 63 = new element). +func NewRestartOperation() *RestartOperation { + o := initRestartOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initResultHandling creates a ResultHandling with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initResultHandling() *ResultHandling { + o := &ResultHandling{} + o.SetTypeName("Microflows$ResultHandling") + o.importMappingCall = property.NewPart[element.Element]("ImportMappingCall") + o.importMappingCall.Bind(&o.Base, 0) + o.storeInVariable = property.NewPrimitive[bool]("StoreInVariable", property.DecodeBool) + o.storeInVariable.Bind(&o.Base, 1) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 2) + o.variableDataType = property.NewPrimitive[string]("VariableDataType", property.DecodeString) + o.variableDataType.Bind(&o.Base, 3) + o.variableType = property.NewPart[element.Element]("VariableType") + o.variableType.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.importMappingCall, o.storeInVariable, o.outputVariableName, o.variableDataType, o.variableType, }) + return o +} + +// NewResultHandling creates a new ResultHandling for user code. Marked dirty (bit 63 = new element). +func NewResultHandling() *ResultHandling { + o := initResultHandling() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initResumeOperation creates a ResumeOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initResumeOperation() *ResumeOperation { + o := &ResumeOperation{} + o.SetTypeName("Microflows$ResumeOperation") + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.workflowVariable, }) + return o +} + +// NewResumeOperation creates a new ResumeOperation for user code. Marked dirty (bit 63 = new element). +func NewResumeOperation() *ResumeOperation { + o := initResumeOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRetrieveAction creates a RetrieveAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRetrieveAction() *RetrieveAction { + o := &RetrieveAction{} + o.SetTypeName("Microflows$RetrieveAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.retrieveSource = property.NewPart[element.Element]("RetrieveSource") + o.retrieveSource.Bind(&o.Base, 1) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.retrieveSource, o.outputVariableName, }) + return o +} + +// NewRetrieveAction creates a new RetrieveAction for user code. Marked dirty (bit 63 = new element). +func NewRetrieveAction() *RetrieveAction { + o := initRetrieveAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRetryOperation creates a RetryOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRetryOperation() *RetryOperation { + o := &RetryOperation{} + o.SetTypeName("Microflows$RetryOperation") + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.workflowVariable, }) + return o +} + +// NewRetryOperation creates a new RetryOperation for user code. Marked dirty (bit 63 = new element). +func NewRetryOperation() *RetryOperation { + o := initRetryOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRollbackAction creates a RollbackAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRollbackAction() *RollbackAction { + o := &RollbackAction{} + o.SetTypeName("Microflows$RollbackAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.rollbackVariableName = property.NewPrimitive[string]("RollbackVariableName", property.DecodeString) + o.rollbackVariableName.Bind(&o.Base, 1) + o.refreshInClient = property.NewPrimitive[bool]("RefreshInClient", property.DecodeBool) + o.refreshInClient.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.rollbackVariableName, o.refreshInClient, }) + return o +} + +// NewRollbackAction creates a new RollbackAction for user code. Marked dirty (bit 63 = new element). +func NewRollbackAction() *RollbackAction { + o := initRollbackAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRule creates a Rule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRule() *Rule { + o := &Rule{} + o.SetTypeName("Microflows$Rule") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.objectCollection = property.NewPart[element.Element]("ObjectCollection") + o.objectCollection.Bind(&o.Base, 4) + o.flows = property.NewPartList[element.Element]("Flows") + o.flows.Bind(&o.Base, 5) + o.returnType = property.NewPrimitive[string]("ReturnType", property.DecodeString) + o.returnType.Bind(&o.Base, 6) + o.microflowReturnType = property.NewPart[element.Element]("MicroflowReturnType") + o.microflowReturnType.Bind(&o.Base, 7) + o.markAsUsed = property.NewPrimitive[bool]("MarkAsUsed", property.DecodeBool) + o.markAsUsed.Bind(&o.Base, 8) + o.returnVariableName = property.NewPrimitive[string]("ReturnVariableName", property.DecodeString) + o.returnVariableName.Bind(&o.Base, 9) + o.applyEntityAccess = property.NewPrimitive[bool]("ApplyEntityAccess", property.DecodeBool) + o.applyEntityAccess.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.objectCollection, o.flows, o.returnType, o.microflowReturnType, o.markAsUsed, o.returnVariableName, o.applyEntityAccess, }) + return o +} + +// NewRule creates a new Rule for user code. Marked dirty (bit 63 = new element). +func NewRule() *Rule { + o := initRule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRuleCall creates a RuleCall with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRuleCall() *RuleCall { + o := &RuleCall{} + o.SetTypeName("Microflows$RuleCall") + o.rule = property.NewByNameRef[element.Element]("Rule", "Microflows$Rule") + o.rule.Bind(&o.Base, 0) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.rule, o.parameterMappings, }) + return o +} + +// NewRuleCall creates a new RuleCall for user code. Marked dirty (bit 63 = new element). +func NewRuleCall() *RuleCall { + o := initRuleCall() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRuleCallParameterMapping creates a RuleCallParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRuleCallParameterMapping() *RuleCallParameterMapping { + o := &RuleCallParameterMapping{} + o.SetTypeName("Microflows$RuleCallParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Microflows$RuleParameter") + o.parameter.Bind(&o.Base, 0) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 1) + o.argumentModel = property.NewPart[element.Element]("ArgumentModel") + o.argumentModel.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.parameter, o.argument, o.argumentModel, }) + return o +} + +// NewRuleCallParameterMapping creates a new RuleCallParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewRuleCallParameterMapping() *RuleCallParameterMapping { + o := initRuleCallParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRuleSplitCondition creates a RuleSplitCondition with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRuleSplitCondition() *RuleSplitCondition { + o := &RuleSplitCondition{} + o.SetTypeName("Microflows$RuleSplitCondition") + o.ruleCall = property.NewPart[element.Element]("RuleCall") + o.ruleCall.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.ruleCall, }) + return o +} + +// NewRuleSplitCondition creates a new RuleSplitCondition for user code. Marked dirty (bit 63 = new element). +func NewRuleSplitCondition() *RuleSplitCondition { + o := initRuleSplitCondition() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSendEmailAction creates a SendEmailAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSendEmailAction() *SendEmailAction { + o := &SendEmailAction{} + o.SetTypeName("Microflows$SendEmailAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.emailAuthenticationConfig = property.NewPart[element.Element]("EmailAuthenticationConfig") + o.emailAuthenticationConfig.Bind(&o.Base, 1) + o.emailConnectionConfig = property.NewPart[element.Element]("EmailConnectionConfig") + o.emailConnectionConfig.Bind(&o.Base, 2) + o.emailMessage = property.NewPart[element.Element]("EmailMessage") + o.emailMessage.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.emailAuthenticationConfig, o.emailConnectionConfig, o.emailMessage, }) + return o +} + +// NewSendEmailAction creates a new SendEmailAction for user code. Marked dirty (bit 63 = new element). +func NewSendEmailAction() *SendEmailAction { + o := initSendEmailAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSendExternalObject creates a SendExternalObject with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSendExternalObject() *SendExternalObject { + o := &SendExternalObject{} + o.SetTypeName("Microflows$SendExternalObject") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.variableNameToBeSent = property.NewPrimitive[string]("VariableNameToBeSent", property.DecodeString) + o.variableNameToBeSent.Bind(&o.Base, 1) + o.refreshInClient = property.NewPrimitive[bool]("RefreshInClient", property.DecodeBool) + o.refreshInClient.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.variableNameToBeSent, o.refreshInClient, }) + return o +} + +// NewSendExternalObject creates a new SendExternalObject for user code. Marked dirty (bit 63 = new element). +func NewSendExternalObject() *SendExternalObject { + o := initSendExternalObject() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSequenceFlow creates a SequenceFlow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSequenceFlow() *SequenceFlow { + o := &SequenceFlow{} + o.SetTypeName("Microflows$SequenceFlow") + o.origin = property.NewByIdRef[element.Element]("OriginPointer") + o.origin.Bind(&o.Base, 0) + o.destination = property.NewByIdRef[element.Element]("DestinationPointer") + o.destination.Bind(&o.Base, 1) + o.originConnectionIndex = property.NewPrimitive[int32]("OriginConnectionIndex", property.DecodeInt32) + o.originConnectionIndex.Bind(&o.Base, 2) + o.destinationConnectionIndex = property.NewPrimitive[int32]("DestinationConnectionIndex", property.DecodeInt32) + o.destinationConnectionIndex.Bind(&o.Base, 3) + o.originBezierVector = property.NewPrimitive[string]("OriginBezierVector", property.DecodeString) + o.originBezierVector.Bind(&o.Base, 4) + o.destinationBezierVector = property.NewPrimitive[string]("DestinationBezierVector", property.DecodeString) + o.destinationBezierVector.Bind(&o.Base, 5) + o.lineType = property.NewEnum[string]("LineType") + o.lineType.Bind(&o.Base, 6) + o.line = property.NewPart[element.Element]("Line") + o.line.Bind(&o.Base, 7) + o.caseValue = property.NewPart[element.Element]("CaseValue") + o.caseValue.Bind(&o.Base, 8) + o.caseValues = property.NewPartList[element.Element]("CaseValues") + o.caseValues.Bind(&o.Base, 9) + o.isErrorHandler = property.NewPrimitive[bool]("IsErrorHandler", property.DecodeBool) + o.isErrorHandler.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.origin, o.destination, o.originConnectionIndex, o.destinationConnectionIndex, o.originBezierVector, o.destinationBezierVector, o.lineType, o.line, o.caseValue, o.caseValues, o.isErrorHandler, }) + return o +} + +// NewSequenceFlow creates a new SequenceFlow for user code. Marked dirty (bit 63 = new element). +func NewSequenceFlow() *SequenceFlow { + o := initSequenceFlow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSetTaskOutcomeAction creates a SetTaskOutcomeAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSetTaskOutcomeAction() *SetTaskOutcomeAction { + o := &SetTaskOutcomeAction{} + o.SetTypeName("Microflows$SetTaskOutcomeAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflowTaskVariable = property.NewPrimitive[string]("WorkflowTaskVariable", property.DecodeString) + o.workflowTaskVariable.Bind(&o.Base, 1) + o.outcome = property.NewByNameRef[element.Element]("Outcome", "Workflows$UserTaskOutcome") + o.outcome.Bind(&o.Base, 2) + o.outcomeValue = property.NewPrimitive[string]("OutcomeValue", property.DecodeString) + o.outcomeValue.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflowTaskVariable, o.outcome, o.outcomeValue, }) + return o +} + +// NewSetTaskOutcomeAction creates a new SetTaskOutcomeAction for user code. Marked dirty (bit 63 = new element). +func NewSetTaskOutcomeAction() *SetTaskOutcomeAction { + o := initSetTaskOutcomeAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initShowHomePageAction creates a ShowHomePageAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initShowHomePageAction() *ShowHomePageAction { + o := &ShowHomePageAction{} + o.SetTypeName("Microflows$ShowHomePageAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.errorHandlingType, }) + return o +} + +// NewShowHomePageAction creates a new ShowHomePageAction for user code. Marked dirty (bit 63 = new element). +func NewShowHomePageAction() *ShowHomePageAction { + o := initShowHomePageAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initShowMessageAction creates a ShowMessageAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initShowMessageAction() *ShowMessageAction { + o := &ShowMessageAction{} + o.SetTypeName("Microflows$ShowMessageAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.template = property.NewPart[element.Element]("Template") + o.template.Bind(&o.Base, 1) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 2) + o.blocking = property.NewPrimitive[bool]("Blocking", property.DecodeBool) + o.blocking.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.template, o.propType, o.blocking, }) + return o +} + +// NewShowMessageAction creates a new ShowMessageAction for user code. Marked dirty (bit 63 = new element). +func NewShowMessageAction() *ShowMessageAction { + o := initShowMessageAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initShowPageAction creates a ShowPageAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initShowPageAction() *ShowPageAction { + o := &ShowPageAction{} + o.SetTypeName("Microflows$ShowFormAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.pageSettings = property.NewPart[element.Element]("PageSettings") + o.pageSettings.Bind(&o.Base, 1) + o.passedObjectVariableName = property.NewPrimitive[string]("PassedObjectVariableName", property.DecodeString) + o.passedObjectVariableName.Bind(&o.Base, 2) + o.numberOfPagesToClose = property.NewPrimitive[string]("NumberOfPagesToClose", property.DecodeString) + o.numberOfPagesToClose.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.pageSettings, o.passedObjectVariableName, o.numberOfPagesToClose, }) + return o +} + +// NewShowPageAction creates a new ShowPageAction for user code. Marked dirty (bit 63 = new element). +func NewShowPageAction() *ShowPageAction { + o := initShowPageAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSimpleRequestHandling creates a SimpleRequestHandling with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSimpleRequestHandling() *SimpleRequestHandling { + o := &SimpleRequestHandling{} + o.SetTypeName("Microflows$SimpleRequestHandling") + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 0) + o.nullValueOption = property.NewEnum[string]("NullValueOption") + o.nullValueOption.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameterMappings, o.nullValueOption, }) + return o +} + +// NewSimpleRequestHandling creates a new SimpleRequestHandling for user code. Marked dirty (bit 63 = new element). +func NewSimpleRequestHandling() *SimpleRequestHandling { + o := initSimpleRequestHandling() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSort creates a Sort with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSort() *Sort { + o := &Sort{} + o.SetTypeName("Microflows$Sort") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.sortItemList = property.NewPart[element.Element]("SortItemList") + o.sortItemList.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.listVariableName, o.sortItemList, }) + return o +} + +// NewSort creates a new Sort for user code. Marked dirty (bit 63 = new element). +func NewSort() *Sort { + o := initSort() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSortItem creates a SortItem with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSortItem() *SortItem { + o := &SortItem{} + o.SetTypeName("Microflows$SortItem") + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 0) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 1) + o.sortOrder = property.NewEnum[string]("SortOrder") + o.sortOrder.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.attributePath, o.attributeRef, o.sortOrder, }) + return o +} + +// NewSortItem creates a new SortItem for user code. Marked dirty (bit 63 = new element). +func NewSortItem() *SortItem { + o := initSortItem() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSortItemList creates a SortItemList with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSortItemList() *SortItemList { + o := &SortItemList{} + o.SetTypeName("Microflows$SortItemList") + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.items, }) + return o +} + +// NewSortItemList creates a new SortItemList for user code. Marked dirty (bit 63 = new element). +func NewSortItemList() *SortItemList { + o := initSortItemList() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStartEvent creates a StartEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStartEvent() *StartEvent { + o := &StartEvent{} + o.SetTypeName("Microflows$StartEvent") + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 0) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.relativeMiddlePoint, o.size, }) + return o +} + +// NewStartEvent creates a new StartEvent for user code. Marked dirty (bit 63 = new element). +func NewStartEvent() *StartEvent { + o := initStartEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringTemplate creates a StringTemplate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringTemplate() *StringTemplate { + o := &StringTemplate{} + o.SetTypeName("Microflows$StringTemplate") + o.arguments = property.NewPartList[element.Element]("Arguments") + o.arguments.Bind(&o.Base, 0) + o.text = property.NewPrimitive[string]("Text", property.DecodeString) + o.text.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.arguments, o.text, }) + return o +} + +// NewStringTemplate creates a new StringTemplate for user code. Marked dirty (bit 63 = new element). +func NewStringTemplate() *StringTemplate { + o := initStringTemplate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringTemplateParameterValue creates a StringTemplateParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringTemplateParameterValue() *StringTemplateParameterValue { + o := &StringTemplateParameterValue{} + o.SetTypeName("Microflows$StringTemplateParameterValue") + o.template = property.NewPart[element.Element]("Template") + o.template.Bind(&o.Base, 0) + o.typedTemplate = property.NewPart[element.Element]("TypedTemplate") + o.typedTemplate.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.template, o.typedTemplate, }) + return o +} + +// NewStringTemplateParameterValue creates a new StringTemplateParameterValue for user code. Marked dirty (bit 63 = new element). +func NewStringTemplateParameterValue() *StringTemplateParameterValue { + o := initStringTemplateParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSubtract creates a Subtract with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSubtract() *Subtract { + o := &Subtract{} + o.SetTypeName("Microflows$Subtract") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.secondListOrObjectVariableName = property.NewPrimitive[string]("SecondListOrObjectVariableName", property.DecodeString) + o.secondListOrObjectVariableName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.listVariableName, o.secondListOrObjectVariableName, }) + return o +} + +// NewSubtract creates a new Subtract for user code. Marked dirty (bit 63 = new element). +func NewSubtract() *Subtract { + o := initSubtract() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSynchronizeAction creates a SynchronizeAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSynchronizeAction() *SynchronizeAction { + o := &SynchronizeAction{} + o.SetTypeName("Microflows$SynchronizeAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 1) + o.variableNames = property.NewPrimitive[string]("VariableNames", property.DecodeString) + o.variableNames.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.errorHandlingType, o.propType, o.variableNames, }) + return o +} + +// NewSynchronizeAction creates a new SynchronizeAction for user code. Marked dirty (bit 63 = new element). +func NewSynchronizeAction() *SynchronizeAction { + o := initSynchronizeAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTail creates a Tail with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTail() *Tail { + o := &Tail{} + o.SetTypeName("Microflows$Tail") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.listVariableName, }) + return o +} + +// NewTail creates a new Tail for user code. Marked dirty (bit 63 = new element). +func NewTail() *Tail { + o := initTail() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTemplateArgument creates a TemplateArgument with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTemplateArgument() *TemplateArgument { + o := &TemplateArgument{} + o.SetTypeName("Microflows$TemplateParameter") + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 0) + o.expressionModel = property.NewPart[element.Element]("ExpressionModel") + o.expressionModel.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.expression, o.expressionModel, }) + return o +} + +// NewTemplateArgument creates a new TemplateArgument for user code. Marked dirty (bit 63 = new element). +func NewTemplateArgument() *TemplateArgument { + o := initTemplateArgument() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTextTemplate creates a TextTemplate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTextTemplate() *TextTemplate { + o := &TextTemplate{} + o.SetTypeName("Microflows$TextTemplate") + o.arguments = property.NewPartList[element.Element]("Arguments") + o.arguments.Bind(&o.Base, 0) + o.text = property.NewPart[element.Element]("Text") + o.text.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.arguments, o.text, }) + return o +} + +// NewTextTemplate creates a new TextTemplate for user code. Marked dirty (bit 63 = new element). +func NewTextTemplate() *TextTemplate { + o := initTextTemplate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTransformJsonAction creates a TransformJsonAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTransformJsonAction() *TransformJsonAction { + o := &TransformJsonAction{} + o.SetTypeName("Microflows$TransformJsonAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.transformation = property.NewByNameRef[element.Element]("Transformation", "DataTransformers$DataTransformer") + o.transformation.Bind(&o.Base, 1) + o.inputVariableName = property.NewPrimitive[string]("InputVariableName", property.DecodeString) + o.inputVariableName.Bind(&o.Base, 2) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.transformation, o.inputVariableName, o.outputVariableName, }) + return o +} + +// NewTransformJsonAction creates a new TransformJsonAction for user code. Marked dirty (bit 63 = new element). +func NewTransformJsonAction() *TransformJsonAction { + o := initTransformJsonAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTypedTemplate creates a TypedTemplate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTypedTemplate() *TypedTemplate { + o := &TypedTemplate{} + o.SetTypeName("Microflows$TypedTemplate") + o.text = property.NewPrimitive[string]("Text", property.DecodeString) + o.text.Bind(&o.Base, 0) + o.arguments = property.NewPartList[element.Element]("Arguments") + o.arguments.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.text, o.arguments, }) + return o +} + +// NewTypedTemplate creates a new TypedTemplate for user code. Marked dirty (bit 63 = new element). +func NewTypedTemplate() *TypedTemplate { + o := initTypedTemplate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUnion creates a Union with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUnion() *Union { + o := &Union{} + o.SetTypeName("Microflows$Union") + o.listVariableName = property.NewPrimitive[string]("ListVariableName", property.DecodeString) + o.listVariableName.Bind(&o.Base, 0) + o.secondListOrObjectVariableName = property.NewPrimitive[string]("SecondListOrObjectVariableName", property.DecodeString) + o.secondListOrObjectVariableName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.listVariableName, o.secondListOrObjectVariableName, }) + return o +} + +// NewUnion creates a new Union for user code. Marked dirty (bit 63 = new element). +func NewUnion() *Union { + o := initUnion() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUnlockWorkflowAction creates a UnlockWorkflowAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUnlockWorkflowAction() *UnlockWorkflowAction { + o := &UnlockWorkflowAction{} + o.SetTypeName("Microflows$UnlockWorkflowAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflow = property.NewByNameRef[element.Element]("Workflow", "Workflows$Workflow") + o.workflow.Bind(&o.Base, 1) + o.workflowSelection = property.NewPart[element.Element]("WorkflowSelection") + o.workflowSelection.Bind(&o.Base, 2) + o.resumeAllPausedWorkflows = property.NewPrimitive[bool]("ResumeAllPausedWorkflows", property.DecodeBool) + o.resumeAllPausedWorkflows.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflow, o.workflowSelection, o.resumeAllPausedWorkflows, }) + return o +} + +// NewUnlockWorkflowAction creates a new UnlockWorkflowAction for user code. Marked dirty (bit 63 = new element). +func NewUnlockWorkflowAction() *UnlockWorkflowAction { + o := initUnlockWorkflowAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUnpauseOperation creates a UnpauseOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUnpauseOperation() *UnpauseOperation { + o := &UnpauseOperation{} + o.SetTypeName("Microflows$UnpauseOperation") + o.workflowVariable = property.NewPrimitive[string]("WorkflowVariable", property.DecodeString) + o.workflowVariable.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.workflowVariable, }) + return o +} + +// NewUnpauseOperation creates a new UnpauseOperation for user code. Marked dirty (bit 63 = new element). +func NewUnpauseOperation() *UnpauseOperation { + o := initUnpauseOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initValidationFeedbackAction creates a ValidationFeedbackAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initValidationFeedbackAction() *ValidationFeedbackAction { + o := &ValidationFeedbackAction{} + o.SetTypeName("Microflows$ValidationFeedbackAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.feedbackTemplate = property.NewPart[element.Element]("FeedbackTemplate") + o.feedbackTemplate.Bind(&o.Base, 1) + o.objectVariableName = property.NewPrimitive[string]("ObjectVariableName", property.DecodeString) + o.objectVariableName.Bind(&o.Base, 2) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 3) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.feedbackTemplate, o.objectVariableName, o.attribute, o.association, }) + return o +} + +// NewValidationFeedbackAction creates a new ValidationFeedbackAction for user code. Marked dirty (bit 63 = new element). +func NewValidationFeedbackAction() *ValidationFeedbackAction { + o := initValidationFeedbackAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initVariableExport creates a VariableExport with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initVariableExport() *VariableExport { + o := &VariableExport{} + o.SetTypeName("ExportXmlAction$StringExport") + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.outputVariableName, }) + return o +} + +// NewVariableExport creates a new VariableExport for user code. Marked dirty (bit 63 = new element). +func NewVariableExport() *VariableExport { + o := initVariableExport() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWebServiceCallAction creates a WebServiceCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWebServiceCallAction() *WebServiceCallAction { + o := &WebServiceCallAction{} + o.SetTypeName("Microflows$WebServiceCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.importedWebService = property.NewByNameRef[element.Element]("ImportedWebService", "WebServices$ImportedWebService") + o.importedWebService.Bind(&o.Base, 1) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 2) + o.operationName = property.NewPrimitive[string]("OperationName", property.DecodeString) + o.operationName.Bind(&o.Base, 3) + o.useRequestTimeOut = property.NewPrimitive[bool]("UseRequestTimeOut", property.DecodeBool) + o.useRequestTimeOut.Bind(&o.Base, 4) + o.timeOut = property.NewPrimitive[int32]("TimeOut", property.DecodeInt32) + o.timeOut.Bind(&o.Base, 5) + o.timeOutModel = property.NewPart[element.Element]("TimeOutModel") + o.timeOutModel.Bind(&o.Base, 6) + o.timeOutExpression = property.NewPrimitive[string]("TimeOutExpression", property.DecodeString) + o.timeOutExpression.Bind(&o.Base, 7) + o.sendNullValueChoice = property.NewEnum[string]("SendNullValueChoice") + o.sendNullValueChoice.Bind(&o.Base, 8) + o.requestHeaderHandling = property.NewPart[element.Element]("RequestHeaderHandling") + o.requestHeaderHandling.Bind(&o.Base, 9) + o.requestBodyHandling = property.NewPart[element.Element]("RequestBodyHandling") + o.requestBodyHandling.Bind(&o.Base, 10) + o.resultHandling = property.NewPart[element.Element]("ResultHandling") + o.resultHandling.Bind(&o.Base, 11) + o.httpConfiguration = property.NewPart[element.Element]("HttpConfiguration") + o.httpConfiguration.Bind(&o.Base, 12) + o.isValidationRequired = property.NewPrimitive[bool]("IsValidationRequired", property.DecodeBool) + o.isValidationRequired.Bind(&o.Base, 13) + o.requestProxyType = property.NewEnum[string]("RequestProxyType") + o.requestProxyType.Bind(&o.Base, 14) + o.proxyConfiguration = property.NewPart[element.Element]("ProxyConfiguration") + o.proxyConfiguration.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.errorHandlingType, o.importedWebService, o.serviceName, o.operationName, o.useRequestTimeOut, o.timeOut, o.timeOutModel, o.timeOutExpression, o.sendNullValueChoice, o.requestHeaderHandling, o.requestBodyHandling, o.resultHandling, o.httpConfiguration, o.isValidationRequired, o.requestProxyType, o.proxyConfiguration, }) + return o +} + +// NewWebServiceCallAction creates a new WebServiceCallAction for user code. Marked dirty (bit 63 = new element). +func NewWebServiceCallAction() *WebServiceCallAction { + o := initWebServiceCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWebServiceOperationAdvancedParameterMapping creates a WebServiceOperationAdvancedParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWebServiceOperationAdvancedParameterMapping() *WebServiceOperationAdvancedParameterMapping { + o := &WebServiceOperationAdvancedParameterMapping{} + o.SetTypeName("Microflows$WebServiceOperationAdvancedParameterMapping") + o.isChecked = property.NewPrimitive[bool]("IsChecked", property.DecodeBool) + o.isChecked.Bind(&o.Base, 0) + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 1) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 2) + o.argumentModel = property.NewPart[element.Element]("ArgumentModel") + o.argumentModel.Bind(&o.Base, 3) + o.mapping = property.NewByNameRef[element.Element]("Mapping", "ExportMappings$ExportMapping") + o.mapping.Bind(&o.Base, 4) + o.mappingArgumentVariableName = property.NewPrimitive[string]("MappingArgumentVariableName", property.DecodeString) + o.mappingArgumentVariableName.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.isChecked, o.parameterName, o.argument, o.argumentModel, o.mapping, o.mappingArgumentVariableName, }) + return o +} + +// NewWebServiceOperationAdvancedParameterMapping creates a new WebServiceOperationAdvancedParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewWebServiceOperationAdvancedParameterMapping() *WebServiceOperationAdvancedParameterMapping { + o := initWebServiceOperationAdvancedParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWebServiceOperationSimpleParameterMapping creates a WebServiceOperationSimpleParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWebServiceOperationSimpleParameterMapping() *WebServiceOperationSimpleParameterMapping { + o := &WebServiceOperationSimpleParameterMapping{} + o.SetTypeName("Microflows$WebServiceOperationSimpleParameterMapping") + o.isChecked = property.NewPrimitive[bool]("IsChecked", property.DecodeBool) + o.isChecked.Bind(&o.Base, 0) + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 1) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 2) + o.argumentModel = property.NewPart[element.Element]("ArgumentModel") + o.argumentModel.Bind(&o.Base, 3) + o.parameterPath = property.NewPrimitive[string]("ParameterPath", property.DecodeString) + o.parameterPath.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.isChecked, o.parameterName, o.argument, o.argumentModel, o.parameterPath, }) + return o +} + +// NewWebServiceOperationSimpleParameterMapping creates a new WebServiceOperationSimpleParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewWebServiceOperationSimpleParameterMapping() *WebServiceOperationSimpleParameterMapping { + o := initWebServiceOperationSimpleParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWhileLoopCondition creates a WhileLoopCondition with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWhileLoopCondition() *WhileLoopCondition { + o := &WhileLoopCondition{} + o.SetTypeName("Microflows$WhileLoopCondition") + o.whileExpression = property.NewPrimitive[string]("WhileExpression", property.DecodeString) + o.whileExpression.Bind(&o.Base, 0) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.whileExpression, o.caption, }) + return o +} + +// NewWhileLoopCondition creates a new WhileLoopCondition for user code. Marked dirty (bit 63 = new element). +func NewWhileLoopCondition() *WhileLoopCondition { + o := initWhileLoopCondition() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowCallAction creates a WorkflowCallAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowCallAction() *WorkflowCallAction { + o := &WorkflowCallAction{} + o.SetTypeName("Microflows$WorkflowCallAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.workflow = property.NewByNameRef[element.Element]("Workflow", "Workflows$Workflow") + o.workflow.Bind(&o.Base, 1) + o.workflowContextVariable = property.NewPrimitive[string]("WorkflowContextVariable", property.DecodeString) + o.workflowContextVariable.Bind(&o.Base, 2) + o.useReturnVariable = property.NewPrimitive[bool]("UseReturnVariable", property.DecodeBool) + o.useReturnVariable.Bind(&o.Base, 3) + o.outputVariableName = property.NewPrimitive[string]("VariableName", property.DecodeString) + o.outputVariableName.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.errorHandlingType, o.workflow, o.workflowContextVariable, o.useReturnVariable, o.outputVariableName, }) + return o +} + +// NewWorkflowCallAction creates a new WorkflowCallAction for user code. Marked dirty (bit 63 = new element). +func NewWorkflowCallAction() *WorkflowCallAction { + o := initWorkflowCallAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowOperationAction creates a WorkflowOperationAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowOperationAction() *WorkflowOperationAction { + o := &WorkflowOperationAction{} + o.SetTypeName("Microflows$WorkflowOperationAction") + o.errorHandlingType = property.NewEnum[string]("ErrorHandlingType") + o.errorHandlingType.Bind(&o.Base, 0) + o.operation = property.NewPart[element.Element]("Operation") + o.operation.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.errorHandlingType, o.operation, }) + return o +} + +// NewWorkflowOperationAction creates a new WorkflowOperationAction for user code. Marked dirty (bit 63 = new element). +func NewWorkflowOperationAction() *WorkflowOperationAction { + o := initWorkflowOperationAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + + +func init() { + codec.DefaultRegistry.Register("Microflows$AbortOperation", func() element.Element { + return initAbortOperation() + }) + codec.DefaultRegistry.Register("Microflows$ActionActivity", func() element.Element { + return initActionActivity() + }) + codec.DefaultRegistry.Register("Microflows$AdditionalAttribute", func() element.Element { + return initAdditionalAttribute() + }) + codec.DefaultRegistry.Register("Microflows$AdvancedRequestHandling", func() element.Element { + return initAdvancedRequestHandling() + }) + codec.DefaultRegistry.Register("Microflows$AggregateListAction", func() element.Element { + o := initAggregateListAction() + o.SetTypeName("Microflows$AggregateListAction") + return o + }) + codec.DefaultRegistry.Register("Microflows$AggregateAction", func() element.Element { + return initAggregateListAction() + }) + codec.DefaultRegistry.Register("Microflows$Annotation", func() element.Element { + return initAnnotation() + }) + codec.DefaultRegistry.Register("Microflows$AnnotationFlow", func() element.Element { + return initAnnotationFlow() + }) + codec.DefaultRegistry.Register("Microflows$AppServiceCallAction", func() element.Element { + return initAppServiceCallAction() + }) + codec.DefaultRegistry.Register("Microflows$AppServiceCallParameterMapping", func() element.Element { + return initAppServiceCallParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$ApplyJumpToOptionAction", func() element.Element { + return initApplyJumpToOptionAction() + }) + codec.DefaultRegistry.Register("Microflows$AssociationRetrieveSource", func() element.Element { + return initAssociationRetrieveSource() + }) + codec.DefaultRegistry.Register("Microflows$AuthenticationDocumentConfig", func() element.Element { + return initAuthenticationDocumentConfig() + }) + codec.DefaultRegistry.Register("Microflows$BasicAuthConfig", func() element.Element { + return initBasicAuthConfig() + }) + codec.DefaultRegistry.Register("Microflows$BasicCodeActionParameterValue", func() element.Element { + return initBasicCodeActionParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$BasicJavaActionParameterValue", func() element.Element { + return initBasicJavaActionParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$BezierCurve", func() element.Element { + return initBezierCurve() + }) + codec.DefaultRegistry.Register("Microflows$BinaryRequestHandling", func() element.Element { + return initBinaryRequestHandling() + }) + codec.DefaultRegistry.Register("Microflows$BodyVariable", func() element.Element { + return initBodyVariable() + }) + codec.DefaultRegistry.Register("Microflows$BreakEvent", func() element.Element { + return initBreakEvent() + }) + codec.DefaultRegistry.Register("Microflows$CallExternalAction", func() element.Element { + return initCallExternalAction() + }) + codec.DefaultRegistry.Register("Microflows$CancelSynchronizationAction", func() element.Element { + return initCancelSynchronizationAction() + }) + codec.DefaultRegistry.Register("Microflows$CastAction", func() element.Element { + return initCastAction() + }) + codec.DefaultRegistry.Register("Microflows$ChangeListAction", func() element.Element { + return initChangeListAction() + }) + codec.DefaultRegistry.Register("Microflows$ChangeObjectAction", func() element.Element { + o := initChangeObjectAction() + o.SetTypeName("Microflows$ChangeObjectAction") + return o + }) + codec.DefaultRegistry.Register("Microflows$ChangeAction", func() element.Element { + return initChangeObjectAction() + }) + codec.DefaultRegistry.Register("Microflows$ChangeVariableAction", func() element.Element { + return initChangeVariableAction() + }) + codec.DefaultRegistry.Register("Microflows$ClearFromClientAction", func() element.Element { + return initClearFromClientAction() + }) + codec.DefaultRegistry.Register("Microflows$CloseFormAction", func() element.Element { + return initCloseFormAction() + }) + codec.DefaultRegistry.Register("Microflows$CommitAction", func() element.Element { + return initCommitAction() + }) + codec.DefaultRegistry.Register("Microflows$ConstantRange", func() element.Element { + return initConstantRange() + }) + codec.DefaultRegistry.Register("Microflows$Contains", func() element.Element { + return initContains() + }) + codec.DefaultRegistry.Register("Microflows$ContinueEvent", func() element.Element { + return initContinueEvent() + }) + codec.DefaultRegistry.Register("Microflows$ContinueOperation", func() element.Element { + return initContinueOperation() + }) + codec.DefaultRegistry.Register("Microflows$CounterMeterAction", func() element.Element { + return initCounterMeterAction() + }) + codec.DefaultRegistry.Register("Microflows$CreateListAction", func() element.Element { + return initCreateListAction() + }) + codec.DefaultRegistry.Register("Microflows$CreateObjectAction", func() element.Element { + o := initCreateObjectAction() + o.SetTypeName("Microflows$CreateObjectAction") + return o + }) + codec.DefaultRegistry.Register("Microflows$CreateChangeAction", func() element.Element { + return initCreateObjectAction() + }) + codec.DefaultRegistry.Register("Microflows$CreateVariableAction", func() element.Element { + return initCreateVariableAction() + }) + codec.DefaultRegistry.Register("Microflows$CustomBlobDocumentCodeActionParameterValue", func() element.Element { + return initCustomBlobDocumentCodeActionParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$CustomRange", func() element.Element { + return initCustomRange() + }) + codec.DefaultRegistry.Register("Microflows$CustomRequestHandling", func() element.Element { + return initCustomRequestHandling() + }) + codec.DefaultRegistry.Register("Microflows$DatabaseRetrieveSource", func() element.Element { + return initDatabaseRetrieveSource() + }) + codec.DefaultRegistry.Register("Microflows$DeleteAction", func() element.Element { + return initDeleteAction() + }) + codec.DefaultRegistry.Register("Microflows$DeleteExternalObject", func() element.Element { + return initDeleteExternalObject() + }) + codec.DefaultRegistry.Register("Microflows$DocumentTemplateParameterMapping", func() element.Element { + return initDocumentTemplateParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$DownloadFileAction", func() element.Element { + return initDownloadFileAction() + }) + codec.DefaultRegistry.Register("Microflows$EmailConnectionConfig", func() element.Element { + return initEmailConnectionConfig() + }) + codec.DefaultRegistry.Register("Microflows$EmailMessage", func() element.Element { + return initEmailMessage() + }) + codec.DefaultRegistry.Register("Microflows$EndEvent", func() element.Element { + return initEndEvent() + }) + codec.DefaultRegistry.Register("Microflows$EntityTypeCodeActionParameterValue", func() element.Element { + return initEntityTypeCodeActionParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$EntityTypeJavaActionParameterValue", func() element.Element { + return initEntityTypeJavaActionParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$EnumerationCase", func() element.Element { + return initEnumerationCase() + }) + codec.DefaultRegistry.Register("Microflows$ErrorEvent", func() element.Element { + return initErrorEvent() + }) + codec.DefaultRegistry.Register("Microflows$ExclusiveMerge", func() element.Element { + return initExclusiveMerge() + }) + codec.DefaultRegistry.Register("Microflows$ExclusiveSplit", func() element.Element { + return initExclusiveSplit() + }) + codec.DefaultRegistry.Register("Microflows$ExportMappingJavaActionParameterValue", func() element.Element { + return initExportMappingJavaActionParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$ExportMappingParameterValue", func() element.Element { + return initExportMappingParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$ExportXmlAction", func() element.Element { + return initExportXmlAction() + }) + codec.DefaultRegistry.Register("Microflows$ExpressionSplitCondition", func() element.Element { + return initExpressionSplitCondition() + }) + codec.DefaultRegistry.Register("Microflows$ExternalActionParameterMapping", func() element.Element { + return initExternalActionParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$FileDocumentExport", func() element.Element { + o := initFileDocumentExport() + o.SetTypeName("Microflows$FileDocumentExport") + return o + }) + codec.DefaultRegistry.Register("ExportXmlAction$FileDocumentExport", func() element.Element { + return initFileDocumentExport() + }) + codec.DefaultRegistry.Register("Microflows$Filter", func() element.Element { + return initFilter() + }) + codec.DefaultRegistry.Register("Microflows$FilterByExpression", func() element.Element { + return initFilterByExpression() + }) + codec.DefaultRegistry.Register("Microflows$Find", func() element.Element { + return initFind() + }) + codec.DefaultRegistry.Register("Microflows$FindByExpression", func() element.Element { + return initFindByExpression() + }) + codec.DefaultRegistry.Register("Microflows$FormDataPart", func() element.Element { + return initFormDataPart() + }) + codec.DefaultRegistry.Register("Microflows$FormDataRequestHandling", func() element.Element { + return initFormDataRequestHandling() + }) + codec.DefaultRegistry.Register("Microflows$GaugeMeterAction", func() element.Element { + return initGaugeMeterAction() + }) + codec.DefaultRegistry.Register("Microflows$GenerateDocumentAction", func() element.Element { + return initGenerateDocumentAction() + }) + codec.DefaultRegistry.Register("Microflows$GenerateJumpToOptionsAction", func() element.Element { + return initGenerateJumpToOptionsAction() + }) + codec.DefaultRegistry.Register("Microflows$GetWorkflowActivityRecordsAction", func() element.Element { + return initGetWorkflowActivityRecordsAction() + }) + codec.DefaultRegistry.Register("Microflows$GetWorkflowDataAction", func() element.Element { + return initGetWorkflowDataAction() + }) + codec.DefaultRegistry.Register("Microflows$GetWorkflowsAction", func() element.Element { + return initGetWorkflowsAction() + }) + codec.DefaultRegistry.Register("Microflows$Head", func() element.Element { + return initHead() + }) + codec.DefaultRegistry.Register("Microflows$HttpConfiguration", func() element.Element { + return initHttpConfiguration() + }) + codec.DefaultRegistry.Register("Microflows$HttpHeaderEntry", func() element.Element { + return initHttpHeaderEntry() + }) + codec.DefaultRegistry.Register("Microflows$ImportMappingCall", func() element.Element { + return initImportMappingCall() + }) + codec.DefaultRegistry.Register("Microflows$ImportMappingJavaActionParameterValue", func() element.Element { + return initImportMappingJavaActionParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$ImportMappingParameterValue", func() element.Element { + return initImportMappingParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$ImportXmlAction", func() element.Element { + return initImportXmlAction() + }) + codec.DefaultRegistry.Register("Microflows$IncludedAssociation", func() element.Element { + return initIncludedAssociation() + }) + codec.DefaultRegistry.Register("Microflows$IncrementCounterMeterAction", func() element.Element { + return initIncrementCounterMeterAction() + }) + codec.DefaultRegistry.Register("Microflows$InheritanceCase", func() element.Element { + return initInheritanceCase() + }) + codec.DefaultRegistry.Register("Microflows$InheritanceSplit", func() element.Element { + return initInheritanceSplit() + }) + codec.DefaultRegistry.Register("Microflows$Intersect", func() element.Element { + return initIntersect() + }) + codec.DefaultRegistry.Register("Microflows$IterableList", func() element.Element { + return initIterableList() + }) + codec.DefaultRegistry.Register("Microflows$JavaActionCallAction", func() element.Element { + return initJavaActionCallAction() + }) + codec.DefaultRegistry.Register("Microflows$JavaActionParameterMapping", func() element.Element { + return initJavaActionParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$JavaScriptActionCallAction", func() element.Element { + return initJavaScriptActionCallAction() + }) + codec.DefaultRegistry.Register("Microflows$JavaScriptActionParameterMapping", func() element.Element { + return initJavaScriptActionParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$ListEquals", func() element.Element { + return initListEquals() + }) + codec.DefaultRegistry.Register("Microflows$ListOperationAction", func() element.Element { + o := initListOperationAction() + o.SetTypeName("Microflows$ListOperationAction") + return o + }) + codec.DefaultRegistry.Register("Microflows$ListOperationsAction", func() element.Element { + return initListOperationAction() + }) + codec.DefaultRegistry.Register("Microflows$ListRange", func() element.Element { + return initListRange() + }) + codec.DefaultRegistry.Register("Microflows$LockWorkflowAction", func() element.Element { + return initLockWorkflowAction() + }) + codec.DefaultRegistry.Register("Microflows$LogMessageAction", func() element.Element { + return initLogMessageAction() + }) + codec.DefaultRegistry.Register("Microflows$LoopedActivity", func() element.Element { + return initLoopedActivity() + }) + codec.DefaultRegistry.Register("Microflows$MLModelCall", func() element.Element { + return initMLModelCall() + }) + codec.DefaultRegistry.Register("Microflows$MLModelCallAction", func() element.Element { + return initMLModelCallAction() + }) + codec.DefaultRegistry.Register("Microflows$MLModelCallParameterMapping", func() element.Element { + return initMLModelCallParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$MappingRequestHandling", func() element.Element { + return initMappingRequestHandling() + }) + codec.DefaultRegistry.Register("Microflows$MemberChange", func() element.Element { + o := initMemberChange() + o.SetTypeName("Microflows$MemberChange") + return o + }) + codec.DefaultRegistry.Register("Microflows$ChangeActionItem", func() element.Element { + return initMemberChange() + }) + codec.DefaultRegistry.Register("Microflows$MeterTagMapping", func() element.Element { + return initMeterTagMapping() + }) + codec.DefaultRegistry.Register("Microflows$Microflow", func() element.Element { + return initMicroflow() + }) + codec.DefaultRegistry.Register("Microflows$MicroflowCall", func() element.Element { + return initMicroflowCall() + }) + codec.DefaultRegistry.Register("Microflows$MicroflowCallAction", func() element.Element { + return initMicroflowCallAction() + }) + codec.DefaultRegistry.Register("Microflows$MicroflowCallParameterMapping", func() element.Element { + o := initMicroflowCallParameterMapping() + o.SetTypeName("Microflows$MicroflowCallParameterMapping") + return o + }) + codec.DefaultRegistry.Register("Mappings$MicroflowCallParameterMappingImpl", func() element.Element { + return initMicroflowCallParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$MicroflowJavaActionParameterValue", func() element.Element { + return initMicroflowJavaActionParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$MicroflowObjectCollection", func() element.Element { + return initMicroflowObjectCollection() + }) + codec.DefaultRegistry.Register("Microflows$MicroflowParameter", func() element.Element { + return initMicroflowParameter() + }) + codec.DefaultRegistry.Register("Microflows$MicroflowParameterAttributeUrlSegment", func() element.Element { + return initMicroflowParameterAttributeUrlSegment() + }) + codec.DefaultRegistry.Register("Microflows$MicroflowParameterObject", func() element.Element { + return initMicroflowParameterObject() + }) + codec.DefaultRegistry.Register("Microflows$MicroflowParameterValue", func() element.Element { + return initMicroflowParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$MicroflowPrimitiveParameterUrlSegment", func() element.Element { + return initMicroflowPrimitiveParameterUrlSegment() + }) + codec.DefaultRegistry.Register("Microflows$Nanoflow", func() element.Element { + return initNanoflow() + }) + codec.DefaultRegistry.Register("Microflows$NanoflowCall", func() element.Element { + return initNanoflowCall() + }) + codec.DefaultRegistry.Register("Microflows$NanoflowCallAction", func() element.Element { + return initNanoflowCallAction() + }) + codec.DefaultRegistry.Register("Microflows$NanoflowCallParameterMapping", func() element.Element { + return initNanoflowCallParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$NanoflowParameter", func() element.Element { + return initNanoflowParameter() + }) + codec.DefaultRegistry.Register("Microflows$NoCase", func() element.Element { + return initNoCase() + }) + codec.DefaultRegistry.Register("Microflows$NotifyWorkflowAction", func() element.Element { + return initNotifyWorkflowAction() + }) + codec.DefaultRegistry.Register("Microflows$OpenUserTaskAction", func() element.Element { + return initOpenUserTaskAction() + }) + codec.DefaultRegistry.Register("Microflows$OpenWorkflowAction", func() element.Element { + return initOpenWorkflowAction() + }) + codec.DefaultRegistry.Register("Microflows$OrthogonalPath", func() element.Element { + return initOrthogonalPath() + }) + codec.DefaultRegistry.Register("Microflows$OutputVariable", func() element.Element { + return initOutputVariable() + }) + codec.DefaultRegistry.Register("Microflows$ParameterIdUrlSegment", func() element.Element { + return initParameterIdUrlSegment() + }) + codec.DefaultRegistry.Register("Microflows$PauseOperation", func() element.Element { + return initPauseOperation() + }) + codec.DefaultRegistry.Register("Microflows$PrimitiveTypedTemplateArgument", func() element.Element { + return initPrimitiveTypedTemplateArgument() + }) + codec.DefaultRegistry.Register("Microflows$ProxyConfiguration", func() element.Element { + return initProxyConfiguration() + }) + codec.DefaultRegistry.Register("Microflows$PushToClientAction", func() element.Element { + return initPushToClientAction() + }) + codec.DefaultRegistry.Register("Microflows$QueryParameterMapping", func() element.Element { + return initQueryParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$RestCallAction", func() element.Element { + return initRestCallAction() + }) + codec.DefaultRegistry.Register("Microflows$RestOperationCallAction", func() element.Element { + return initRestOperationCallAction() + }) + codec.DefaultRegistry.Register("Microflows$RestOperationParameterMapping", func() element.Element { + return initRestOperationParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$RestParameterMapping", func() element.Element { + return initRestParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$RestartOperation", func() element.Element { + return initRestartOperation() + }) + codec.DefaultRegistry.Register("Microflows$ResultHandling", func() element.Element { + return initResultHandling() + }) + codec.DefaultRegistry.Register("Microflows$ResumeOperation", func() element.Element { + return initResumeOperation() + }) + codec.DefaultRegistry.Register("Microflows$RetrieveAction", func() element.Element { + return initRetrieveAction() + }) + codec.DefaultRegistry.Register("Microflows$RetryOperation", func() element.Element { + return initRetryOperation() + }) + codec.DefaultRegistry.Register("Microflows$RollbackAction", func() element.Element { + return initRollbackAction() + }) + codec.DefaultRegistry.Register("Microflows$Rule", func() element.Element { + return initRule() + }) + codec.DefaultRegistry.Register("Microflows$RuleCall", func() element.Element { + return initRuleCall() + }) + codec.DefaultRegistry.Register("Microflows$RuleCallParameterMapping", func() element.Element { + return initRuleCallParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$RuleSplitCondition", func() element.Element { + return initRuleSplitCondition() + }) + codec.DefaultRegistry.Register("Microflows$SendEmailAction", func() element.Element { + return initSendEmailAction() + }) + codec.DefaultRegistry.Register("Microflows$SendExternalObject", func() element.Element { + return initSendExternalObject() + }) + codec.DefaultRegistry.Register("Microflows$SequenceFlow", func() element.Element { + return initSequenceFlow() + }) + codec.DefaultRegistry.Register("Microflows$SetTaskOutcomeAction", func() element.Element { + return initSetTaskOutcomeAction() + }) + codec.DefaultRegistry.Register("Microflows$ShowHomePageAction", func() element.Element { + return initShowHomePageAction() + }) + codec.DefaultRegistry.Register("Microflows$ShowMessageAction", func() element.Element { + return initShowMessageAction() + }) + codec.DefaultRegistry.Register("Microflows$ShowPageAction", func() element.Element { + o := initShowPageAction() + o.SetTypeName("Microflows$ShowPageAction") + return o + }) + codec.DefaultRegistry.Register("Microflows$ShowFormAction", func() element.Element { + return initShowPageAction() + }) + codec.DefaultRegistry.Register("Microflows$SimpleRequestHandling", func() element.Element { + return initSimpleRequestHandling() + }) + codec.DefaultRegistry.Register("Microflows$Sort", func() element.Element { + return initSort() + }) + codec.DefaultRegistry.Register("Microflows$SortItem", func() element.Element { + return initSortItem() + }) + codec.DefaultRegistry.Register("Microflows$SortItemList", func() element.Element { + return initSortItemList() + }) + codec.DefaultRegistry.Register("Microflows$StartEvent", func() element.Element { + return initStartEvent() + }) + codec.DefaultRegistry.Register("Microflows$StringTemplate", func() element.Element { + return initStringTemplate() + }) + codec.DefaultRegistry.Register("Microflows$StringTemplateParameterValue", func() element.Element { + return initStringTemplateParameterValue() + }) + codec.DefaultRegistry.Register("Microflows$Subtract", func() element.Element { + return initSubtract() + }) + codec.DefaultRegistry.Register("Microflows$SynchronizeAction", func() element.Element { + return initSynchronizeAction() + }) + codec.DefaultRegistry.Register("Microflows$Tail", func() element.Element { + return initTail() + }) + codec.DefaultRegistry.Register("Microflows$TemplateArgument", func() element.Element { + o := initTemplateArgument() + o.SetTypeName("Microflows$TemplateArgument") + return o + }) + codec.DefaultRegistry.Register("Microflows$TemplateParameter", func() element.Element { + return initTemplateArgument() + }) + codec.DefaultRegistry.Register("Microflows$TextTemplate", func() element.Element { + return initTextTemplate() + }) + codec.DefaultRegistry.Register("Microflows$TransformJsonAction", func() element.Element { + return initTransformJsonAction() + }) + codec.DefaultRegistry.Register("Microflows$TypedTemplate", func() element.Element { + return initTypedTemplate() + }) + codec.DefaultRegistry.Register("Microflows$Union", func() element.Element { + return initUnion() + }) + codec.DefaultRegistry.Register("Microflows$UnlockWorkflowAction", func() element.Element { + return initUnlockWorkflowAction() + }) + codec.DefaultRegistry.Register("Microflows$UnpauseOperation", func() element.Element { + return initUnpauseOperation() + }) + codec.DefaultRegistry.Register("Microflows$ValidationFeedbackAction", func() element.Element { + return initValidationFeedbackAction() + }) + codec.DefaultRegistry.Register("Microflows$VariableExport", func() element.Element { + o := initVariableExport() + o.SetTypeName("Microflows$VariableExport") + return o + }) + codec.DefaultRegistry.Register("ExportXmlAction$StringExport", func() element.Element { + return initVariableExport() + }) + codec.DefaultRegistry.Register("Microflows$WebServiceCallAction", func() element.Element { + return initWebServiceCallAction() + }) + codec.DefaultRegistry.Register("Microflows$WebServiceOperationAdvancedParameterMapping", func() element.Element { + return initWebServiceOperationAdvancedParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$WebServiceOperationSimpleParameterMapping", func() element.Element { + return initWebServiceOperationSimpleParameterMapping() + }) + codec.DefaultRegistry.Register("Microflows$WhileLoopCondition", func() element.Element { + return initWhileLoopCondition() + }) + codec.DefaultRegistry.Register("Microflows$WorkflowCallAction", func() element.Element { + return initWorkflowCallAction() + }) + codec.DefaultRegistry.Register("Microflows$WorkflowOperationAction", func() element.Element { + return initWorkflowOperationAction() + }) +} diff --git a/modelsdk/gen/microflows/version.go b/modelsdk/gen/microflows/version.go new file mode 100644 index 00000000..954996ff --- /dev/null +++ b/modelsdk/gen/microflows/version.go @@ -0,0 +1,637 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package microflows + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Microflows$AbortOperation": { + Properties: map[string]version.PropertyVersionInfo{ + "reason": {Required: true}, + }, + }, + "Microflows$MicroflowObject": { + Properties: map[string]version.PropertyVersionInfo{ + "relativeMiddlePoint": {}, + }, + }, + "Microflows$ActionActivity": { + Properties: map[string]version.PropertyVersionInfo{ + "disabled": {Introduced: "9.12.0"}, + }, + }, + "Microflows$AdditionalAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Introduced: "11.6.0"}, + "attributeDataType": {Introduced: "11.6.0", Required: true}, + "type": {Required: true}, + }, + }, + "Microflows$AdvancedRequestHandling": { + Properties: map[string]version.PropertyVersionInfo{ + "nullValueOption": {Introduced: "6.7.0"}, + }, + }, + "Microflows$AggregateListAction": { + Properties: map[string]version.PropertyVersionInfo{ + "aggregateFunction": {Introduced: "10.0.0", Required: true}, + "expression": {Introduced: "10.0.0"}, + "reduceInitialValueExpression": {Introduced: "10.0.0"}, + "useExpression": {Introduced: "10.0.0"}, + }, + }, + "Microflows$AggregateAction": { + Properties: map[string]version.PropertyVersionInfo{ + "aggregateFunction": {Introduced: "10.0.0", Required: true}, + "expression": {Introduced: "10.0.0"}, + "reduceInitialValueExpression": {Introduced: "10.0.0"}, + "useExpression": {Introduced: "10.0.0"}, + }, + }, + "Microflows$Annotation": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {}, + }, + }, + "Microflows$Flow": { + Properties: map[string]version.PropertyVersionInfo{ + "destination": {Required: true}, + "destinationBezierVector": {Deleted: "10.16.0"}, + "line": {Introduced: "10.16.0", Required: true}, + "lineType": {Introduced: "10.8.0", Deleted: "10.16.0"}, + "origin": {Required: true}, + "originBezierVector": {Deleted: "10.16.0"}, + "originConnectionIndex": {}, + }, + }, + "Microflows$AppServiceCallParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "argumentModel": {Introduced: "7.9.0", Required: true}, + }, + }, + "Microflows$BasicCodeActionParameterValue": { + Properties: map[string]version.PropertyVersionInfo{ + "argumentModel": {Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$BasicJavaActionParameterValue": { + Properties: map[string]version.PropertyVersionInfo{ + "argumentModel": {Introduced: "7.9.0", Required: true}, + }, + }, + "Microflows$BinaryRequestHandling": { + Properties: map[string]version.PropertyVersionInfo{ + "expressionModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$CallExternalAction": { + Properties: map[string]version.PropertyVersionInfo{ + "consumedODataService": {}, + "includedAssociations": {Introduced: "10.12.0"}, + "parameterMappings": {Introduced: "10.2.0"}, + "variableDataType": {Introduced: "10.2.0", Required: true}, + "variableName": {Introduced: "10.2.0"}, + }, + }, + "Microflows$ChangeListAction": { + Properties: map[string]version.PropertyVersionInfo{ + "valueModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$ChangeVariableAction": { + Properties: map[string]version.PropertyVersionInfo{ + "valueModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$CloseFormAction": { + Properties: map[string]version.PropertyVersionInfo{ + "numberOfPages": {Introduced: "8.9.0", Deleted: "8.11.0"}, + "numberOfPagesToClose": {Introduced: "8.11.0"}, + }, + }, + "Microflows$CreateVariableAction": { + Properties: map[string]version.PropertyVersionInfo{ + "initialValueModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "variableDataType": {Deleted: "7.9.0"}, + "variableType": {Introduced: "7.9.0", Required: true}, + }, + }, + "Microflows$CustomRange": { + Properties: map[string]version.PropertyVersionInfo{ + "limitExpressionModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "offsetExpressionModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$CustomRequestHandling": { + Properties: map[string]version.PropertyVersionInfo{ + "template": {Required: true}, + }, + }, + "Microflows$DatabaseRetrieveSource": { + Properties: map[string]version.PropertyVersionInfo{ + "range": {Required: true}, + "sortItemList": {Required: true}, + }, + }, + "Microflows$DocumentTemplateParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "argumentModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$EmailMessage": { + Properties: map[string]version.PropertyVersionInfo{ + "attachment": {Introduced: "11.3.0"}, + "attachments": {Deleted: "11.3.0"}, + }, + }, + "Microflows$EndEvent": { + Properties: map[string]version.PropertyVersionInfo{ + "returnValueModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$ExclusiveSplit": { + Properties: map[string]version.PropertyVersionInfo{ + "splitCondition": {Required: true}, + }, + }, + "Microflows$ExportXmlAction": { + Properties: map[string]version.PropertyVersionInfo{ + "mapping": {Deleted: "7.6.0"}, + "mappingArgumentVariableName": {Deleted: "7.6.0"}, + "outputMethod": {Required: true}, + "resultHandling": {Introduced: "7.6.0", Required: true}, + }, + }, + "Microflows$ExpressionListOperation": { + Properties: map[string]version.PropertyVersionInfo{ + "expressionModel": {Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$ExpressionSplitCondition": { + Properties: map[string]version.PropertyVersionInfo{ + "expressionModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$ExternalActionParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "additionalAttributes": {Introduced: "11.5.0"}, + "includedAssociations": {Introduced: "10.11.0"}, + "parameterType": {Required: true}, + }, + }, + "Microflows$InspectAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "association": {Introduced: "7.0.0"}, + "expressionModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$FormDataPart": { + Properties: map[string]version.PropertyVersionInfo{ + "headerEntries": {Introduced: "9.2.0"}, + "valueModel": {Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$FormDataRequestHandling": { + Properties: map[string]version.PropertyVersionInfo{ + "parts": {}, + }, + }, + "Microflows$GenerateDocumentAction": { + Properties: map[string]version.PropertyVersionInfo{ + "marginBottomInInchModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "marginLeftInInchModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "marginRightInInchModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "marginTopInInchModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$GenerateJumpToOptionsAction": { + Properties: map[string]version.PropertyVersionInfo{ + "workflow": {Deleted: "9.16.0"}, + }, + }, + "Microflows$HttpConfiguration": { + Properties: map[string]version.PropertyVersionInfo{ + "clientCertificate": {Introduced: "8.18.0"}, + "customLocationModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "customLocationTemplate": {Introduced: "6.6.0"}, + "httpMethod": {Introduced: "6.6.0", Deleted: "7.7.0"}, + "newHttpMethod": {Introduced: "7.7.0"}, + "password": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "username": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$HttpHeaderEntry": { + Properties: map[string]version.PropertyVersionInfo{ + "valueModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$ImportMappingCall": { + Properties: map[string]version.PropertyVersionInfo{ + "commit": {Introduced: "7.18.0"}, + "contentType": {Introduced: "7.6.0"}, + "forceSingleOccurrence": {Introduced: "7.8.0"}, + "objectHandlingBackup": {Introduced: "7.17.0"}, + "range": {Required: true}, + }, + }, + "Microflows$ImportXmlAction": { + Properties: map[string]version.PropertyVersionInfo{ + "resultHandling": {Required: true}, + }, + }, + "Microflows$IncludedAssociation": { + Properties: map[string]version.PropertyVersionInfo{ + "association": {Required: true}, + }, + }, + "Microflows$JavaActionCallAction": { + Properties: map[string]version.PropertyVersionInfo{ + "queue": {Introduced: "9.0.5", Deleted: "9.10.0"}, + "queueSettings": {Introduced: "9.10.0"}, + "useReturnVariable": {Introduced: "7.13.0"}, + }, + }, + "Microflows$JavaActionParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "argument": {Deleted: "6.7.0"}, + "parameter": {Required: true}, + "parameterValue": {Introduced: "7.21.0", Required: true}, + "value": {Introduced: "6.7.0", Deleted: "7.21.0", Required: true}, + }, + }, + "Microflows$JavaScriptActionParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true}, + "parameterValue": {Required: true}, + }, + }, + "Microflows$ListOperationAction": { + Properties: map[string]version.PropertyVersionInfo{ + "operation": {Required: true}, + }, + }, + "Microflows$ListOperationsAction": { + Properties: map[string]version.PropertyVersionInfo{ + "operation": {Required: true}, + }, + }, + "Microflows$ListRange": { + Properties: map[string]version.PropertyVersionInfo{ + "customRange": {Required: true}, + }, + }, + "Microflows$LockWorkflowAction": { + Properties: map[string]version.PropertyVersionInfo{ + "workflow": {Deleted: "10.0.0"}, + "workflowSelection": {Introduced: "10.0.0"}, + }, + }, + "Microflows$LogMessageAction": { + Properties: map[string]version.PropertyVersionInfo{ + "messageTemplate": {Required: true}, + "nodeModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$LoopedActivity": { + Properties: map[string]version.PropertyVersionInfo{ + "iteratedListVariableName": {Deleted: "9.0.4"}, + "loopSource": {Introduced: "9.0.4", Required: true}, + "loopVariableName": {Deleted: "9.0.4"}, + "objectCollection": {Required: true}, + }, + }, + "Microflows$MLModelCall": { + Properties: map[string]version.PropertyVersionInfo{ + "mlMappingDocument": {Introduced: "9.17.0"}, + }, + }, + "Microflows$MLModelCallAction": { + Properties: map[string]version.PropertyVersionInfo{ + "inputVariableName": {Introduced: "9.18.0"}, + "mlMappingDocument": {Introduced: "9.18.0"}, + "modelCall": {Deleted: "9.18.0", Required: true}, + }, + }, + "Microflows$MLModelCallParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "parameterType": {Required: true}, + }, + }, + "Microflows$MappingRequestHandling": { + Properties: map[string]version.PropertyVersionInfo{ + "contentType": {Introduced: "7.6.0"}, + }, + }, + "Microflows$MemberChange": { + Properties: map[string]version.PropertyVersionInfo{ + "valueModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$ChangeActionItem": { + Properties: map[string]version.PropertyVersionInfo{ + "valueModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$MicroflowBase": { + Properties: map[string]version.PropertyVersionInfo{ + "microflowReturnType": {Introduced: "7.9.0", Required: true, Public: true}, + "objectCollection": {Required: true}, + "returnType": {Deleted: "7.9.0", Public: true}, + "returnVariableName": {Introduced: "10.12.0"}, + }, + }, + "Microflows$Microflow": { + Properties: map[string]version.PropertyVersionInfo{ + "allowedModuleRoles": {Public: true}, + "concurrencyErrorMessage": {Required: true}, + "microflowActionInfo": {Introduced: "8.0.0", Public: true}, + "stableId": {Introduced: "10.2.0"}, + "url": {Introduced: "10.1.0"}, + "urlSearchParameters": {Introduced: "10.9.0"}, + "workflowActionInfo": {Introduced: "9.0.2", Public: true}, + }, + }, + "Microflows$MicroflowCall": { + Properties: map[string]version.PropertyVersionInfo{ + "queue": {Introduced: "8.16.0", Deleted: "9.10.0"}, + "queueSettings": {Introduced: "9.10.0"}, + }, + }, + "Microflows$MicroflowCallAction": { + Properties: map[string]version.PropertyVersionInfo{ + "microflowCall": {Required: true}, + }, + }, + "Microflows$MicroflowCallParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "argumentModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "parameter": {Required: true}, + }, + }, + "Mappings$MicroflowCallParameterMappingImpl": { + Properties: map[string]version.PropertyVersionInfo{ + "argumentModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "parameter": {Required: true}, + }, + }, + "Microflows$MicroflowParameterBase": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "parameterType": {Introduced: "7.9.0", Required: true, Public: true}, + "type": {Deleted: "7.9.0", Public: true}, + }, + }, + "Microflows$MicroflowParameterAttributeUrlSegment": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Required: true}, + "microflowParameter": {Required: true}, + }, + }, + "Microflows$MicroflowParameterObject": { + Properties: map[string]version.PropertyVersionInfo{ + "defaultValue": {Introduced: "10.17.0"}, + "hasVariableNameBeenChanged": {Introduced: "9.17.0"}, + "isRequired": {Introduced: "10.17.0"}, + "type": {Deleted: "7.9.0"}, + "variableType": {Introduced: "7.9.0", Required: true}, + }, + }, + "Microflows$MicroflowPrimitiveParameterUrlSegment": { + Properties: map[string]version.PropertyVersionInfo{ + "microflowParameter": {Required: true}, + }, + }, + "Microflows$Nanoflow": { + Properties: map[string]version.PropertyVersionInfo{ + "allowedModuleRoles": {Public: true}, + "useListParameterByReference": {Introduced: "11.9.0"}, + }, + }, + "Microflows$NanoflowCallAction": { + Properties: map[string]version.PropertyVersionInfo{ + "nanoflowCall": {Required: true}, + }, + }, + "Microflows$NanoflowCallParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "argumentModel": {Deleted: "9.8.0", Required: true}, + "parameter": {Required: true}, + }, + }, + "Microflows$NotifyWorkflowAction": { + Properties: map[string]version.PropertyVersionInfo{ + "activity": {Deleted: "11.7.0"}, + "notifyTarget": {Introduced: "11.7.0"}, + }, + }, + "Microflows$OpenUserTaskAction": { + Properties: map[string]version.PropertyVersionInfo{ + "assignOnOpen": {Introduced: "9.19.0"}, + "openWhenAssigned": {Introduced: "9.19.0"}, + }, + }, + "Microflows$ParameterIdUrlSegment": { + Properties: map[string]version.PropertyVersionInfo{ + "microflowParameter": {Required: true}, + }, + }, + "Microflows$ProxyConfiguration": { + Properties: map[string]version.PropertyVersionInfo{ + "hostExpressionModel": {Deleted: "9.8.0"}, + "passwordExpressionModel": {Deleted: "9.8.0"}, + "portExpressionModel": {Deleted: "9.8.0"}, + "useConfigurationExpressionModel": {Deleted: "9.8.0"}, + "usernameExpressionModel": {Deleted: "9.8.0"}, + }, + }, + "Microflows$QueryParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "queryParameter": {Required: true}, + }, + }, + "Microflows$RestCallAction": { + Properties: map[string]version.PropertyVersionInfo{ + "errorResultHandlingType": {Introduced: "7.0.2"}, + "httpConfiguration": {Required: true}, + "proxyConfiguration": {Introduced: "7.15.0"}, + "requestHandling": {Required: true}, + "requestHandlingType": {Introduced: "6.9.0"}, + "requestProxyType": {Introduced: "7.15.0"}, + "resultHandling": {Required: true}, + "resultHandlingType": {Introduced: "6.9.0"}, + "timeOut": {Introduced: "7.1.0", Deleted: "7.15.0"}, + "timeOutExpression": {Introduced: "7.15.0"}, + "timeOutModel": {Introduced: "7.15.0", Deleted: "9.8.0", Required: true}, + "useRequestTimeOut": {Introduced: "7.1.0"}, + }, + }, + "Microflows$RestOperationCallAction": { + Properties: map[string]version.PropertyVersionInfo{ + "baseUrlParameterMapping": {Introduced: "10.17.0"}, + "bodyVariable": {Introduced: "10.5.0"}, + "outputVariable": {Introduced: "10.4.0"}, + "parameterMappings": {Introduced: "10.2.0"}, + "queryParameterMappings": {Introduced: "11.0.0"}, + }, + }, + "Microflows$RestOperationParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true}, + }, + }, + "Microflows$RestParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true}, + }, + }, + "Microflows$ResultHandling": { + Properties: map[string]version.PropertyVersionInfo{ + "variableDataType": {Introduced: "6.10.0", Deleted: "7.9.0", Required: true}, + "variableType": {Introduced: "7.9.0", Required: true}, + }, + }, + "Microflows$RetrieveAction": { + Properties: map[string]version.PropertyVersionInfo{ + "retrieveSource": {Required: true}, + }, + }, + "Microflows$RuleCallParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "argumentModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "parameter": {Required: true}, + }, + }, + "Microflows$RuleSplitCondition": { + Properties: map[string]version.PropertyVersionInfo{ + "ruleCall": {Required: true}, + }, + }, + "Microflows$SendEmailAction": { + Properties: map[string]version.PropertyVersionInfo{ + "emailConnectionConfig": {Required: true}, + "emailMessage": {Required: true}, + }, + }, + "Microflows$SendExternalObject": { + Properties: map[string]version.PropertyVersionInfo{ + "refreshInClient": {Introduced: "9.7.0"}, + }, + }, + "Microflows$SequenceFlow": { + Properties: map[string]version.PropertyVersionInfo{ + "caseValue": {Deleted: "10.15.0", Required: true}, + "caseValues": {Introduced: "10.15.0"}, + }, + }, + "Microflows$SetTaskOutcomeAction": { + Properties: map[string]version.PropertyVersionInfo{ + "outcome": {Deleted: "9.19.0"}, + "outcomeValue": {Introduced: "9.19.0"}, + }, + }, + "Microflows$ShowMessageAction": { + Properties: map[string]version.PropertyVersionInfo{ + "template": {Required: true}, + }, + }, + "Microflows$ShowPageAction": { + Properties: map[string]version.PropertyVersionInfo{ + "numberOfPagesToClose": {Introduced: "8.11.0"}, + "pageSettings": {Required: true}, + "passedObjectVariableName": {Deleted: "9.18.0"}, + }, + }, + "Microflows$ShowFormAction": { + Properties: map[string]version.PropertyVersionInfo{ + "numberOfPagesToClose": {Introduced: "8.11.0"}, + "pageSettings": {Required: true}, + "passedObjectVariableName": {Deleted: "9.18.0"}, + }, + }, + "Microflows$SimpleRequestHandling": { + Properties: map[string]version.PropertyVersionInfo{ + "nullValueOption": {Introduced: "6.7.0"}, + }, + }, + "Microflows$Sort": { + Properties: map[string]version.PropertyVersionInfo{ + "sortItemList": {Required: true}, + }, + }, + "Microflows$SortItem": { + Properties: map[string]version.PropertyVersionInfo{ + "attributePath": {Deleted: "7.11.0", Required: true}, + "attributeRef": {Introduced: "7.11.0", Required: true}, + }, + }, + "Microflows$StringTemplateParameterValue": { + Properties: map[string]version.PropertyVersionInfo{ + "template": {Deleted: "8.6.0", Required: true}, + "typedTemplate": {Introduced: "8.6.0", Required: true}, + }, + }, + "Microflows$SynchronizeAction": { + Properties: map[string]version.PropertyVersionInfo{ + "type": {Introduced: "8.10.0"}, + "variableNames": {Introduced: "8.10.0"}, + }, + }, + "Microflows$TemplateArgument": { + Properties: map[string]version.PropertyVersionInfo{ + "expressionModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$TemplateParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "expressionModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$TextTemplate": { + Properties: map[string]version.PropertyVersionInfo{ + "text": {Required: true}, + }, + }, + "Microflows$TransformJsonAction": { + Properties: map[string]version.PropertyVersionInfo{ + "transformation": {}, + }, + }, + "Microflows$UnlockWorkflowAction": { + Properties: map[string]version.PropertyVersionInfo{ + "workflow": {Deleted: "10.0.0"}, + "workflowSelection": {Introduced: "10.0.0"}, + }, + }, + "Microflows$ValidationFeedbackAction": { + Properties: map[string]version.PropertyVersionInfo{ + "feedbackTemplate": {Required: true}, + }, + }, + "Microflows$WebServiceCallAction": { + Properties: map[string]version.PropertyVersionInfo{ + "httpConfiguration": {Required: true}, + "proxyConfiguration": {Introduced: "7.15.0"}, + "requestBodyHandling": {Required: true}, + "requestHeaderHandling": {Required: true}, + "requestProxyType": {Introduced: "7.15.0"}, + "resultHandling": {Required: true}, + "sendNullValueChoice": {Deleted: "6.7.0"}, + "timeOutExpression": {Introduced: "7.15.0"}, + "timeOutModel": {Introduced: "7.15.0", Deleted: "9.8.0", Required: true}, + "useRequestTimeOut": {Deleted: "7.15.0"}, + }, + }, + "Microflows$WebServiceOperationParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "argumentModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + }, + }, + "Microflows$WorkflowOperationAction": { + Properties: map[string]version.PropertyVersionInfo{ + "operation": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/mlmappings/enums.go b/modelsdk/gen/mlmappings/enums.go new file mode 100644 index 00000000..91e9c328 --- /dev/null +++ b/modelsdk/gen/mlmappings/enums.go @@ -0,0 +1,25 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package mlmappings + +// TensorType enumerates the possible values for the TensorType type. +type TensorType = string + +const ( + TensorTypeUnsignedInteger8Tensor TensorType = "UnsignedInteger8Tensor" + TensorTypeUnsignedInteger16Tensor TensorType = "UnsignedInteger16Tensor" + TensorTypeFloat16Tensor TensorType = "Float16Tensor" + TensorTypeComplex64Tensor TensorType = "Complex64Tensor" + TensorTypeComplex128Tensor TensorType = "Complex128Tensor" + TensorTypeInteger8Tensor TensorType = "Integer8Tensor" + TensorTypeInteger16Tensor TensorType = "Integer16Tensor" + TensorTypeInteger32Tensor TensorType = "Integer32Tensor" + TensorTypeInteger64Tensor TensorType = "Integer64Tensor" + TensorTypeFloat32Tensor TensorType = "Float32Tensor" + TensorTypeFloat64Tensor TensorType = "Float64Tensor" + TensorTypeStringTensor TensorType = "StringTensor" + TensorTypeBooleanTensor TensorType = "BooleanTensor" + TensorTypeUnknownTensor TensorType = "UnknownTensor" +) diff --git a/modelsdk/gen/mlmappings/refs.go b/modelsdk/gen/mlmappings/refs.go new file mode 100644 index 00000000..c3a95c99 --- /dev/null +++ b/modelsdk/gen/mlmappings/refs.go @@ -0,0 +1,16 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package mlmappings + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("MLMappings$MLModelEntityMappings", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("MLMappings$TensorMappingElement", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) +} diff --git a/modelsdk/gen/mlmappings/types.go b/modelsdk/gen/mlmappings/types.go new file mode 100644 index 00000000..b919ef77 --- /dev/null +++ b/modelsdk/gen/mlmappings/types.go @@ -0,0 +1,608 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package mlmappings + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// MLMappingDocument +// ──────────────────────────────────────────────────────── + +type MLMappingDocument struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + mlModelFileName *property.Primitive[string] + mlModelMetadata *property.PartList[element.Element] + mlModelMappings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *MLMappingDocument) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MLMappingDocument) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MLMappingDocument) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MLMappingDocument) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *MLMappingDocument) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *MLMappingDocument) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *MLMappingDocument) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *MLMappingDocument) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// MlModelFileName returns the value of the mlModelFileName property. +func (o *MLMappingDocument) MlModelFileName() string { + return o.mlModelFileName.Get() +} + +// SetMlModelFileName sets the value of the mlModelFileName property. +func (o *MLMappingDocument) SetMlModelFileName(v string) { + o.mlModelFileName.Set(v) +} + +// MlModelMetadataItems returns the value of the mlModelMetadata property. +func (o *MLMappingDocument) MlModelMetadataItems() []element.Element { + return o.mlModelMetadata.Items() +} + +// AddMlModelMetadata appends a child element to the mlModelMetadata list. +func (o *MLMappingDocument) AddMlModelMetadata(v element.Element) { + o.mlModelMetadata.Append(v) +} + +// RemoveMlModelMetadata removes the element at the given index from the mlModelMetadata list. +func (o *MLMappingDocument) RemoveMlModelMetadata(index int) { + o.mlModelMetadata.Remove(index) +} + +// MlModelMappings returns the value of the mlModelMappings property. +func (o *MLMappingDocument) MlModelMappings() element.Element { + return o.mlModelMappings.Get() +} + +// SetMlModelMappings sets the value of the mlModelMappings property. +func (o *MLMappingDocument) SetMlModelMappings(v element.Element) { + o.mlModelMappings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MLMappingDocument) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.mlModelFileName.Init(raw) + if children, err := codec.DecodeChildren(raw, "MlModelMetadata"); err == nil { + for _, child := range children { + o.mlModelMetadata.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "MlModelMappings"); err == nil { + o.mlModelMappings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MLModelEntityMappings +// ──────────────────────────────────────────────────────── + +type MLModelEntityMappings struct { + element.Base + entity *property.ByNameRef[element.Element] + mappings *property.PartList[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *MLModelEntityMappings) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *MLModelEntityMappings) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// MappingsItems returns the value of the mappings property. +func (o *MLModelEntityMappings) MappingsItems() []element.Element { + return o.mappings.Items() +} + +// AddMappings appends a child element to the mappings list. +func (o *MLModelEntityMappings) AddMappings(v element.Element) { + o.mappings.Append(v) +} + +// RemoveMappings removes the element at the given index from the mappings list. +func (o *MLModelEntityMappings) RemoveMappings(index int) { + o.mappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MLModelEntityMappings) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Mappings"); err == nil { + for _, child := range children { + o.mappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MLModelMappings +// ──────────────────────────────────────────────────────── + +type MLModelMappings struct { + element.Base + input *property.Part[element.Element] + output *property.Part[element.Element] +} + +// Input returns the value of the input property. +func (o *MLModelMappings) Input() element.Element { + return o.input.Get() +} + +// SetInput sets the value of the input property. +func (o *MLModelMappings) SetInput(v element.Element) { + o.input.Set(v) +} + +// Output returns the value of the output property. +func (o *MLModelMappings) Output() element.Element { + return o.output.Get() +} + +// SetOutput sets the value of the output property. +func (o *MLModelMappings) SetOutput(v element.Element) { + o.output.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MLModelMappings) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Input"); err == nil { + o.input.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Output"); err == nil { + o.output.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MLModelMetadata +// ──────────────────────────────────────────────────────── + +type MLModelMetadata struct { + element.Base + name *property.Primitive[string] + value *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *MLModelMetadata) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MLModelMetadata) SetName(v string) { + o.name.Set(v) +} + +// Value returns the value of the value property. +func (o *MLModelMetadata) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *MLModelMetadata) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MLModelMetadata) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TensorDimension +// ──────────────────────────────────────────────────────── + +type TensorDimension struct { + element.Base + dimension *property.Primitive[int32] +} + +// Dimension returns the value of the dimension property. +func (o *TensorDimension) Dimension() int32 { + return o.dimension.Get() +} + +// SetDimension sets the value of the dimension property. +func (o *TensorDimension) SetDimension(v int32) { + o.dimension.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TensorDimension) InitFromRaw(raw bson.Raw) { + o.dimension.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TensorMappingElement +// ──────────────────────────────────────────────────────── + +type TensorMappingElement struct { + element.Base + attributeName *property.Primitive[string] + attributeType *property.Part[element.Element] + attributeShape *property.PartList[element.Element] + tensorName *property.Primitive[string] + tensorType *property.Enum[string] + tensorShape *property.PartList[element.Element] + staticTensorShape *property.PartList[element.Element] + attribute *property.ByNameRef[element.Element] +} + +// AttributeName returns the value of the attributeName property. +func (o *TensorMappingElement) AttributeName() string { + return o.attributeName.Get() +} + +// SetAttributeName sets the value of the attributeName property. +func (o *TensorMappingElement) SetAttributeName(v string) { + o.attributeName.Set(v) +} + +// AttributeType returns the value of the attributeType property. +func (o *TensorMappingElement) AttributeType() element.Element { + return o.attributeType.Get() +} + +// SetAttributeType sets the value of the attributeType property. +func (o *TensorMappingElement) SetAttributeType(v element.Element) { + o.attributeType.Set(v) +} + +// AttributeShapeItems returns the value of the attributeShape property. +func (o *TensorMappingElement) AttributeShapeItems() []element.Element { + return o.attributeShape.Items() +} + +// AddAttributeShape appends a child element to the attributeShape list. +func (o *TensorMappingElement) AddAttributeShape(v element.Element) { + o.attributeShape.Append(v) +} + +// RemoveAttributeShape removes the element at the given index from the attributeShape list. +func (o *TensorMappingElement) RemoveAttributeShape(index int) { + o.attributeShape.Remove(index) +} + +// TensorName returns the value of the tensorName property. +func (o *TensorMappingElement) TensorName() string { + return o.tensorName.Get() +} + +// SetTensorName sets the value of the tensorName property. +func (o *TensorMappingElement) SetTensorName(v string) { + o.tensorName.Set(v) +} + +// TensorType returns the value of the tensorType property. +func (o *TensorMappingElement) TensorType() string { + return o.tensorType.Get() +} + +// SetTensorType sets the value of the tensorType property. +func (o *TensorMappingElement) SetTensorType(v string) { + o.tensorType.Set(v) +} + +// TensorShapeItems returns the value of the tensorShape property. +func (o *TensorMappingElement) TensorShapeItems() []element.Element { + return o.tensorShape.Items() +} + +// AddTensorShape appends a child element to the tensorShape list. +func (o *TensorMappingElement) AddTensorShape(v element.Element) { + o.tensorShape.Append(v) +} + +// RemoveTensorShape removes the element at the given index from the tensorShape list. +func (o *TensorMappingElement) RemoveTensorShape(index int) { + o.tensorShape.Remove(index) +} + +// StaticTensorShapeItems returns the value of the staticTensorShape property. +func (o *TensorMappingElement) StaticTensorShapeItems() []element.Element { + return o.staticTensorShape.Items() +} + +// AddStaticTensorShape appends a child element to the staticTensorShape list. +func (o *TensorMappingElement) AddStaticTensorShape(v element.Element) { + o.staticTensorShape.Append(v) +} + +// RemoveStaticTensorShape removes the element at the given index from the staticTensorShape list. +func (o *TensorMappingElement) RemoveStaticTensorShape(index int) { + o.staticTensorShape.Remove(index) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *TensorMappingElement) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *TensorMappingElement) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TensorMappingElement) InitFromRaw(raw bson.Raw) { + o.attributeName.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeType"); err == nil { + o.attributeType.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "AttributeShape"); err == nil { + for _, child := range children { + o.attributeShape.AppendFromDecode(child) + } + } + o.tensorName.Init(raw) + if val, err := raw.LookupErr("TensorType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.tensorType.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "TensorShape"); err == nil { + for _, child := range children { + o.tensorShape.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "StaticTensorShape"); err == nil { + for _, child := range children { + o.staticTensorShape.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initMLMappingDocument creates a MLMappingDocument with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMLMappingDocument() *MLMappingDocument { + o := &MLMappingDocument{} + o.SetTypeName("MLMappings$MLMappingDocument") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.mlModelFileName = property.NewPrimitive[string]("MlModelFileName", property.DecodeString) + o.mlModelFileName.Bind(&o.Base, 4) + o.mlModelMetadata = property.NewPartList[element.Element]("MlModelMetadata") + o.mlModelMetadata.Bind(&o.Base, 5) + o.mlModelMappings = property.NewPart[element.Element]("MlModelMappings") + o.mlModelMappings.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.mlModelFileName, o.mlModelMetadata, o.mlModelMappings}) + return o +} + +// NewMLMappingDocument creates a new MLMappingDocument for user code. Marked dirty (bit 63 = new element). +func NewMLMappingDocument() *MLMappingDocument { + o := initMLMappingDocument() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMLModelEntityMappings creates a MLModelEntityMappings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMLModelEntityMappings() *MLModelEntityMappings { + o := &MLModelEntityMappings{} + o.SetTypeName("MLMappings$MLModelEntityMappings") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.mappings = property.NewPartList[element.Element]("Mappings") + o.mappings.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.entity, o.mappings}) + return o +} + +// NewMLModelEntityMappings creates a new MLModelEntityMappings for user code. Marked dirty (bit 63 = new element). +func NewMLModelEntityMappings() *MLModelEntityMappings { + o := initMLModelEntityMappings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMLModelMappings creates a MLModelMappings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMLModelMappings() *MLModelMappings { + o := &MLModelMappings{} + o.SetTypeName("MLMappings$MLModelMappings") + o.input = property.NewPart[element.Element]("Input") + o.input.Bind(&o.Base, 0) + o.output = property.NewPart[element.Element]("Output") + o.output.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.input, o.output}) + return o +} + +// NewMLModelMappings creates a new MLModelMappings for user code. Marked dirty (bit 63 = new element). +func NewMLModelMappings() *MLModelMappings { + o := initMLModelMappings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMLModelMetadata creates a MLModelMetadata with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMLModelMetadata() *MLModelMetadata { + o := &MLModelMetadata{} + o.SetTypeName("MLMappings$MLModelMetadata") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.value}) + return o +} + +// NewMLModelMetadata creates a new MLModelMetadata for user code. Marked dirty (bit 63 = new element). +func NewMLModelMetadata() *MLModelMetadata { + o := initMLModelMetadata() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTensorDimension creates a TensorDimension with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTensorDimension() *TensorDimension { + o := &TensorDimension{} + o.SetTypeName("MLMappings$TensorDimension") + o.dimension = property.NewPrimitive[int32]("Dimension", property.DecodeInt32) + o.dimension.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.dimension}) + return o +} + +// NewTensorDimension creates a new TensorDimension for user code. Marked dirty (bit 63 = new element). +func NewTensorDimension() *TensorDimension { + o := initTensorDimension() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTensorMappingElement creates a TensorMappingElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTensorMappingElement() *TensorMappingElement { + o := &TensorMappingElement{} + o.SetTypeName("MLMappings$TensorMappingElement") + o.attributeName = property.NewPrimitive[string]("AttributeName", property.DecodeString) + o.attributeName.Bind(&o.Base, 0) + o.attributeType = property.NewPart[element.Element]("AttributeType") + o.attributeType.Bind(&o.Base, 1) + o.attributeShape = property.NewPartList[element.Element]("AttributeShape") + o.attributeShape.Bind(&o.Base, 2) + o.tensorName = property.NewPrimitive[string]("TensorName", property.DecodeString) + o.tensorName.Bind(&o.Base, 3) + o.tensorType = property.NewEnum[string]("TensorType") + o.tensorType.Bind(&o.Base, 4) + o.tensorShape = property.NewPartList[element.Element]("TensorShape") + o.tensorShape.Bind(&o.Base, 5) + o.staticTensorShape = property.NewPartList[element.Element]("StaticTensorShape") + o.staticTensorShape.Bind(&o.Base, 6) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.attributeName, o.attributeType, o.attributeShape, o.tensorName, o.tensorType, o.tensorShape, o.staticTensorShape, o.attribute}) + return o +} + +// NewTensorMappingElement creates a new TensorMappingElement for user code. Marked dirty (bit 63 = new element). +func NewTensorMappingElement() *TensorMappingElement { + o := initTensorMappingElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("MLMappings$MLMappingDocument", func() element.Element { + return initMLMappingDocument() + }) + codec.DefaultRegistry.Register("MLMappings$MLModelEntityMappings", func() element.Element { + return initMLModelEntityMappings() + }) + codec.DefaultRegistry.Register("MLMappings$MLModelMappings", func() element.Element { + return initMLModelMappings() + }) + codec.DefaultRegistry.Register("MLMappings$MLModelMetadata", func() element.Element { + return initMLModelMetadata() + }) + codec.DefaultRegistry.Register("MLMappings$TensorDimension", func() element.Element { + return initTensorDimension() + }) + codec.DefaultRegistry.Register("MLMappings$TensorMappingElement", func() element.Element { + return initTensorMappingElement() + }) +} diff --git a/modelsdk/gen/mlmappings/version.go b/modelsdk/gen/mlmappings/version.go new file mode 100644 index 00000000..fbe1582a --- /dev/null +++ b/modelsdk/gen/mlmappings/version.go @@ -0,0 +1,25 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package mlmappings + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "MLMappings$MLMappingDocument": { + Properties: map[string]version.PropertyVersionInfo{ + "mlModelMetadata": {Introduced: "9.22.0"}, + }, + }, + "MLMappings$TensorMappingElement": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Introduced: "9.21.0"}, + "attributeName": {Deleted: "9.21.0"}, + "attributeShape": {Deleted: "9.21.0"}, + "attributeType": {Deleted: "9.21.0"}, + "staticTensorShape": {Introduced: "9.21.0"}, + }, + }, +} diff --git a/modelsdk/gen/nanoflows/enums.go b/modelsdk/gen/nanoflows/enums.go new file mode 100644 index 00000000..ba7ced4b --- /dev/null +++ b/modelsdk/gen/nanoflows/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package nanoflows diff --git a/modelsdk/gen/nanoflows/refs.go b/modelsdk/gen/nanoflows/refs.go new file mode 100644 index 00000000..73d62559 --- /dev/null +++ b/modelsdk/gen/nanoflows/refs.go @@ -0,0 +1,13 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package nanoflows + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Nanoflows$NanoflowParameterValue", []codec.RefMeta{ + {Prop: "Nanoflow", Kind: codec.RefByName, Target: "Microflows$Nanoflow"}, + }) +} diff --git a/modelsdk/gen/nanoflows/types.go b/modelsdk/gen/nanoflows/types.go new file mode 100644 index 00000000..a976be5c --- /dev/null +++ b/modelsdk/gen/nanoflows/types.go @@ -0,0 +1,79 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package nanoflows + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// NanoflowParameterValue +// ──────────────────────────────────────────────────────── + +type NanoflowParameterValue struct { + element.Base + nanoflow *property.ByNameRef[element.Element] +} + +// NanoflowQualifiedName returns the value of the nanoflow property. +func (o *NanoflowParameterValue) NanoflowQualifiedName() string { + return o.nanoflow.QualifiedName() +} + +// SetNanoflowQualifiedName sets the value of the nanoflow property. +func (o *NanoflowParameterValue) SetNanoflowQualifiedName(v string) { + o.nanoflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NanoflowParameterValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Nanoflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.nanoflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initNanoflowParameterValue creates a NanoflowParameterValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNanoflowParameterValue() *NanoflowParameterValue { + o := &NanoflowParameterValue{} + o.SetTypeName("Nanoflows$NanoflowParameterValue") + o.nanoflow = property.NewByNameRef[element.Element]("Nanoflow", "Microflows$Nanoflow") + o.nanoflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.nanoflow}) + return o +} + +// NewNanoflowParameterValue creates a new NanoflowParameterValue for user code. Marked dirty (bit 63 = new element). +func NewNanoflowParameterValue() *NanoflowParameterValue { + o := initNanoflowParameterValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Nanoflows$NanoflowParameterValue", func() element.Element { + return initNanoflowParameterValue() + }) +} diff --git a/modelsdk/gen/nanoflows/version.go b/modelsdk/gen/nanoflows/version.go new file mode 100644 index 00000000..1a60ac6a --- /dev/null +++ b/modelsdk/gen/nanoflows/version.go @@ -0,0 +1,10 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package nanoflows + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{} diff --git a/modelsdk/gen/nativepages/enums.go b/modelsdk/gen/nativepages/enums.go new file mode 100644 index 00000000..ceed4afd --- /dev/null +++ b/modelsdk/gen/nativepages/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package nativepages diff --git a/modelsdk/gen/nativepages/refs.go b/modelsdk/gen/nativepages/refs.go new file mode 100644 index 00000000..fab6e468 --- /dev/null +++ b/modelsdk/gen/nativepages/refs.go @@ -0,0 +1,22 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package nativepages + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("NativePages$BottomBarItem", []codec.RefMeta{ + {Prop: "Page", Kind: codec.RefByName, Target: "Forms$Page"}, + }) + codec.DefaultRefRegistry.RegisterRefs("NativePages$NativeLayoutCallArgument", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Forms$LayoutParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("NativePages$NativePage", []codec.RefMeta{ + {Prop: "Layout", Kind: codec.RefByName, Target: "NativePages$NativeLayout"}, + }) + codec.DefaultRefRegistry.RegisterRefs("NativePages$NativePageClientAction", []codec.RefMeta{ + {Prop: "Page", Kind: codec.RefByName, Target: "NativePages$NativePage"}, + }) +} diff --git a/modelsdk/gen/nativepages/types.go b/modelsdk/gen/nativepages/types.go new file mode 100644 index 00000000..dfc264a4 --- /dev/null +++ b/modelsdk/gen/nativepages/types.go @@ -0,0 +1,698 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package nativepages + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// BottomBarItem +// ──────────────────────────────────────────────────────── + +type BottomBarItem struct { + element.Base + caption *property.Part[element.Element] + icon *property.Part[element.Element] + page *property.ByNameRef[element.Element] + action *property.Part[element.Element] +} + +// Caption returns the value of the caption property. +func (o *BottomBarItem) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *BottomBarItem) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Icon returns the value of the icon property. +func (o *BottomBarItem) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *BottomBarItem) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// PageQualifiedName returns the value of the page property. +func (o *BottomBarItem) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *BottomBarItem) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// Action returns the value of the action property. +func (o *BottomBarItem) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *BottomBarItem) SetAction(v element.Element) { + o.action.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BottomBarItem) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("Page"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.page.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NativeLayout +// ──────────────────────────────────────────────────────── + +type NativeLayout struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + canvasWidth *property.Primitive[int32] + canvasHeight *property.Primitive[int32] + widgets *property.PartList[element.Element] + headerWidget *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *NativeLayout) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NativeLayout) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *NativeLayout) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *NativeLayout) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *NativeLayout) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *NativeLayout) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *NativeLayout) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *NativeLayout) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CanvasWidth returns the value of the canvasWidth property. +func (o *NativeLayout) CanvasWidth() int32 { + return o.canvasWidth.Get() +} + +// SetCanvasWidth sets the value of the canvasWidth property. +func (o *NativeLayout) SetCanvasWidth(v int32) { + o.canvasWidth.Set(v) +} + +// CanvasHeight returns the value of the canvasHeight property. +func (o *NativeLayout) CanvasHeight() int32 { + return o.canvasHeight.Get() +} + +// SetCanvasHeight sets the value of the canvasHeight property. +func (o *NativeLayout) SetCanvasHeight(v int32) { + o.canvasHeight.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *NativeLayout) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *NativeLayout) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *NativeLayout) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// HeaderWidget returns the value of the headerWidget property. +func (o *NativeLayout) HeaderWidget() element.Element { + return o.headerWidget.Get() +} + +// SetHeaderWidget sets the value of the headerWidget property. +func (o *NativeLayout) SetHeaderWidget(v element.Element) { + o.headerWidget.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NativeLayout) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.canvasWidth.Init(raw) + o.canvasHeight.Init(raw) + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "HeaderWidget"); err == nil { + o.headerWidget.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NativeLayoutCallArgument +// ──────────────────────────────────────────────────────── + +type NativeLayoutCallArgument struct { + element.Base + parameter *property.ByNameRef[element.Element] + widgets *property.PartList[element.Element] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *NativeLayoutCallArgument) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *NativeLayoutCallArgument) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *NativeLayoutCallArgument) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *NativeLayoutCallArgument) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *NativeLayoutCallArgument) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NativeLayoutCallArgument) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parameter.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// NativePage +// ──────────────────────────────────────────────────────── + +type NativePage struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + canvasWidth *property.Primitive[int32] + canvasHeight *property.Primitive[int32] + layout *property.ByNameRef[element.Element] + arguments *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *NativePage) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NativePage) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *NativePage) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *NativePage) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *NativePage) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *NativePage) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *NativePage) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *NativePage) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CanvasWidth returns the value of the canvasWidth property. +func (o *NativePage) CanvasWidth() int32 { + return o.canvasWidth.Get() +} + +// SetCanvasWidth sets the value of the canvasWidth property. +func (o *NativePage) SetCanvasWidth(v int32) { + o.canvasWidth.Set(v) +} + +// CanvasHeight returns the value of the canvasHeight property. +func (o *NativePage) CanvasHeight() int32 { + return o.canvasHeight.Get() +} + +// SetCanvasHeight sets the value of the canvasHeight property. +func (o *NativePage) SetCanvasHeight(v int32) { + o.canvasHeight.Set(v) +} + +// LayoutQualifiedName returns the value of the layout property. +func (o *NativePage) LayoutQualifiedName() string { + return o.layout.QualifiedName() +} + +// SetLayoutQualifiedName sets the value of the layout property. +func (o *NativePage) SetLayoutQualifiedName(v string) { + o.layout.SetQualifiedName(v) +} + +// ArgumentsItems returns the value of the arguments property. +func (o *NativePage) ArgumentsItems() []element.Element { + return o.arguments.Items() +} + +// AddArguments appends a child element to the arguments list. +func (o *NativePage) AddArguments(v element.Element) { + o.arguments.Append(v) +} + +// RemoveArguments removes the element at the given index from the arguments list. +func (o *NativePage) RemoveArguments(index int) { + o.arguments.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NativePage) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.canvasWidth.Init(raw) + o.canvasHeight.Init(raw) + if val, err := raw.LookupErr("Layout"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.layout.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Arguments"); err == nil { + for _, child := range children { + o.arguments.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// NativePageClientAction +// ──────────────────────────────────────────────────────── + +type NativePageClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + page *property.ByNameRef[element.Element] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *NativePageClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *NativePageClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// PageQualifiedName returns the value of the page property. +func (o *NativePageClientAction) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *NativePageClientAction) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NativePageClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + if val, err := raw.LookupErr("Page"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.page.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// NativePlaceholder +// ──────────────────────────────────────────────────────── + +type NativePlaceholder struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *NativePlaceholder) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NativePlaceholder) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *NativePlaceholder) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *NativePlaceholder) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *NativePlaceholder) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *NativePlaceholder) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *NativePlaceholder) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *NativePlaceholder) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *NativePlaceholder) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *NativePlaceholder) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NativePlaceholder) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initBottomBarItem creates a BottomBarItem with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBottomBarItem() *BottomBarItem { + o := &BottomBarItem{} + o.SetTypeName("NativePages$BottomBarItem") + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 0) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 1) + o.page = property.NewByNameRef[element.Element]("Page", "Forms$Page") + o.page.Bind(&o.Base, 2) + o.action = property.NewPart[element.Element]("Action") + o.action.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.caption, o.icon, o.page, o.action}) + return o +} + +// NewBottomBarItem creates a new BottomBarItem for user code. Marked dirty (bit 63 = new element). +func NewBottomBarItem() *BottomBarItem { + o := initBottomBarItem() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNativeLayout creates a NativeLayout with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNativeLayout() *NativeLayout { + o := &NativeLayout{} + o.SetTypeName("NativePages$NativeLayout") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.canvasWidth = property.NewPrimitive[int32]("CanvasWidth", property.DecodeInt32) + o.canvasWidth.Bind(&o.Base, 4) + o.canvasHeight = property.NewPrimitive[int32]("CanvasHeight", property.DecodeInt32) + o.canvasHeight.Bind(&o.Base, 5) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 6) + o.headerWidget = property.NewPart[element.Element]("HeaderWidget") + o.headerWidget.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.canvasWidth, o.canvasHeight, o.widgets, o.headerWidget}) + return o +} + +// NewNativeLayout creates a new NativeLayout for user code. Marked dirty (bit 63 = new element). +func NewNativeLayout() *NativeLayout { + o := initNativeLayout() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNativeLayoutCallArgument creates a NativeLayoutCallArgument with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNativeLayoutCallArgument() *NativeLayoutCallArgument { + o := &NativeLayoutCallArgument{} + o.SetTypeName("NativePages$NativeLayoutCallArgument") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Forms$LayoutParameter") + o.parameter.Bind(&o.Base, 0) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameter, o.widgets}) + return o +} + +// NewNativeLayoutCallArgument creates a new NativeLayoutCallArgument for user code. Marked dirty (bit 63 = new element). +func NewNativeLayoutCallArgument() *NativeLayoutCallArgument { + o := initNativeLayoutCallArgument() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNativePage creates a NativePage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNativePage() *NativePage { + o := &NativePage{} + o.SetTypeName("NativePages$NativePage") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.canvasWidth = property.NewPrimitive[int32]("CanvasWidth", property.DecodeInt32) + o.canvasWidth.Bind(&o.Base, 4) + o.canvasHeight = property.NewPrimitive[int32]("CanvasHeight", property.DecodeInt32) + o.canvasHeight.Bind(&o.Base, 5) + o.layout = property.NewByNameRef[element.Element]("Layout", "NativePages$NativeLayout") + o.layout.Bind(&o.Base, 6) + o.arguments = property.NewPartList[element.Element]("Arguments") + o.arguments.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.canvasWidth, o.canvasHeight, o.layout, o.arguments}) + return o +} + +// NewNativePage creates a new NativePage for user code. Marked dirty (bit 63 = new element). +func NewNativePage() *NativePage { + o := initNativePage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNativePageClientAction creates a NativePageClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNativePageClientAction() *NativePageClientAction { + o := &NativePageClientAction{} + o.SetTypeName("NativePages$NativePageClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.page = property.NewByNameRef[element.Element]("Page", "NativePages$NativePage") + o.page.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.page}) + return o +} + +// NewNativePageClientAction creates a new NativePageClientAction for user code. Marked dirty (bit 63 = new element). +func NewNativePageClientAction() *NativePageClientAction { + o := initNativePageClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNativePlaceholder creates a NativePlaceholder with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNativePlaceholder() *NativePlaceholder { + o := &NativePlaceholder{} + o.SetTypeName("NativePages$NativePlaceholder") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex}) + return o +} + +// NewNativePlaceholder creates a new NativePlaceholder for user code. Marked dirty (bit 63 = new element). +func NewNativePlaceholder() *NativePlaceholder { + o := initNativePlaceholder() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("NativePages$BottomBarItem", func() element.Element { + return initBottomBarItem() + }) + codec.DefaultRegistry.Register("NativePages$NativeLayout", func() element.Element { + return initNativeLayout() + }) + codec.DefaultRegistry.Register("NativePages$NativeLayoutCallArgument", func() element.Element { + return initNativeLayoutCallArgument() + }) + codec.DefaultRegistry.Register("NativePages$NativePage", func() element.Element { + return initNativePage() + }) + codec.DefaultRegistry.Register("NativePages$NativePageClientAction", func() element.Element { + return initNativePageClientAction() + }) + codec.DefaultRegistry.Register("NativePages$NativePlaceholder", func() element.Element { + return initNativePlaceholder() + }) +} diff --git a/modelsdk/gen/nativepages/version.go b/modelsdk/gen/nativepages/version.go new file mode 100644 index 00000000..116c525b --- /dev/null +++ b/modelsdk/gen/nativepages/version.go @@ -0,0 +1,34 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package nativepages + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "NativePages$BottomBarItem": { + Properties: map[string]version.PropertyVersionInfo{ + "action": {Deleted: "8.15.0", Required: true}, + "caption": {Required: true}, + "page": {Introduced: "8.15.0"}, + }, + }, + "NativePages$NativeLayout": { + Properties: map[string]version.PropertyVersionInfo{ + "headerWidget": {Introduced: "7.22.0"}, + }, + }, + "NativePages$NativeLayoutCallArgument": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true}, + }, + }, + "NativePages$NativePage": { + Properties: map[string]version.PropertyVersionInfo{ + "arguments": {Introduced: "7.23.0"}, + "layout": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/navigation/enums.go b/modelsdk/gen/navigation/enums.go new file mode 100644 index 00000000..8bf97db0 --- /dev/null +++ b/modelsdk/gen/navigation/enums.go @@ -0,0 +1,87 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package navigation + +// DeviceType enumerates the possible values for the DeviceType type. +type DeviceType = string + +const ( + DeviceTypeDesktop DeviceType = "Desktop" + DeviceTypeTablet DeviceType = "Tablet" + DeviceTypePhone DeviceType = "Phone" +) + +// OfflineEntitySyncDownloadMode enumerates the possible values for the OfflineEntitySyncDownloadMode type. +type OfflineEntitySyncDownloadMode = string + +const ( + OfflineEntitySyncDownloadModeAll OfflineEntitySyncDownloadMode = "All" + OfflineEntitySyncDownloadModeConstrained OfflineEntitySyncDownloadMode = "Constrained" + OfflineEntitySyncDownloadModeNone OfflineEntitySyncDownloadMode = "None" + OfflineEntitySyncDownloadModeNoneAndPreserveData OfflineEntitySyncDownloadMode = "NoneAndPreserveData" +) + +// OfflineEntitySyncMode enumerates the possible values for the OfflineEntitySyncMode type. +type OfflineEntitySyncMode = string + +const ( + OfflineEntitySyncModeAll OfflineEntitySyncMode = "All" + OfflineEntitySyncModeConstrained OfflineEntitySyncMode = "Constrained" + OfflineEntitySyncModeNone OfflineEntitySyncMode = "None" + OfflineEntitySyncModeNoneAndPreserveData OfflineEntitySyncMode = "NoneAndPreserveData" + OfflineEntitySyncModeNever OfflineEntitySyncMode = "Never" + OfflineEntitySyncModeOnline OfflineEntitySyncMode = "Online" +) + +// PopupNavigationTransition enumerates the possible values for the PopupNavigationTransition type. +type PopupNavigationTransition = string + +const ( + PopupNavigationTransitionSystemDefault PopupNavigationTransition = "SystemDefault" + PopupNavigationTransitionModalPresentationIOS PopupNavigationTransition = "ModalPresentationIOS" + PopupNavigationTransitionBottomSheetAndroid PopupNavigationTransition = "BottomSheetAndroid" +) + +// ProfileKind enumerates the possible values for the ProfileKind type. +type ProfileKind = string + +const ( + ProfileKindResponsive ProfileKind = "Responsive" + ProfileKindResponsiveOffline ProfileKind = "ResponsiveOffline" + ProfileKindHybridTablet ProfileKind = "HybridTablet" + ProfileKindHybridTabletOffline ProfileKind = "HybridTabletOffline" + ProfileKindHybridPhone ProfileKind = "HybridPhone" + ProfileKindHybridPhoneOffline ProfileKind = "HybridPhoneOffline" + ProfileKindTablet ProfileKind = "Tablet" + ProfileKindTabletOffline ProfileKind = "TabletOffline" + ProfileKindPhone ProfileKind = "Phone" + ProfileKindPhoneOffline ProfileKind = "PhoneOffline" + ProfileKindNativePhone ProfileKind = "NativePhone" + ProfileKindHybrid ProfileKind = "Hybrid" + ProfileKindHybridOffline ProfileKind = "HybridOffline" +) + +// ProfileType enumerates the possible values for the ProfileType type. +type ProfileType = string + +const ( + ProfileTypeDesktop ProfileType = "Desktop" + ProfileTypeTablet ProfileType = "Tablet" + ProfileTypePhone ProfileType = "Phone" + ProfileTypeHybridTablet ProfileType = "HybridTablet" + ProfileTypeHybridPhone ProfileType = "HybridPhone" + ProfileTypeOfflinePhone ProfileType = "OfflinePhone" + ProfileTypeHybridPhone6 ProfileType = "HybridPhone6" + ProfileTypeHybridTablet6 ProfileType = "HybridTablet6" +) + +// ScreenNavigationTransition enumerates the possible values for the ScreenNavigationTransition type. +type ScreenNavigationTransition = string + +const ( + ScreenNavigationTransitionSystemDefault ScreenNavigationTransition = "SystemDefault" + ScreenNavigationTransitionSlideFromRightIOS ScreenNavigationTransition = "SlideFromRightIOS" + ScreenNavigationTransitionScaleFromCenterAndroid ScreenNavigationTransition = "ScaleFromCenterAndroid" +) diff --git a/modelsdk/gen/navigation/refs.go b/modelsdk/gen/navigation/refs.go new file mode 100644 index 00000000..5a52ef92 --- /dev/null +++ b/modelsdk/gen/navigation/refs.go @@ -0,0 +1,53 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package navigation + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Navigation$HomePageBase", []codec.RefMeta{ + {Prop: "Page", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Navigation$HomePage", []codec.RefMeta{ + {Prop: "Page", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Navigation$NativeHomePageBase", []codec.RefMeta{ + {Prop: "HomePagePage", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "HomePageNanoflow", Kind: codec.RefByName, Target: "Microflows$Nanoflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Navigation$NativeHomePage", []codec.RefMeta{ + {Prop: "HomePagePage", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "HomePageNanoflow", Kind: codec.RefByName, Target: "Microflows$Nanoflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Navigation$NativeNavigationProfile", []codec.RefMeta{ + {Prop: "HomePage", Kind: codec.RefByName, Target: "Forms$Page"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Navigation$NavigationProfile", []codec.RefMeta{ + {Prop: "AppIcon", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Navigation$NotFoundHomePage", []codec.RefMeta{ + {Prop: "Page", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Navigation$OfflineEntityConfig", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Navigation$RoleBasedHomePage", []codec.RefMeta{ + {Prop: "Page", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "UserRole", Kind: codec.RefByName, Target: "Security$UserRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Navigation$RoleBasedNativeHomePage", []codec.RefMeta{ + {Prop: "HomePagePage", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "HomePageNanoflow", Kind: codec.RefByName, Target: "Microflows$Nanoflow"}, + {Prop: "UserRole", Kind: codec.RefByName, Target: "Security$UserRole"}, + {Prop: "Page", Kind: codec.RefByName, Target: "Forms$Page"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Navigation$NavigationProfileLoginFormSettings", []codec.RefMeta{ + {Prop: "LoginPage", Kind: codec.RefByName, Target: "Forms$Page"}, + }) +} diff --git a/modelsdk/gen/navigation/types.go b/modelsdk/gen/navigation/types.go new file mode 100644 index 00000000..9549d5a9 --- /dev/null +++ b/modelsdk/gen/navigation/types.go @@ -0,0 +1,1574 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package navigation + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// HomePageBase +// ──────────────────────────────────────────────────────── + +type HomePageBase struct { + element.Base + page *property.ByNameRef[element.Element] + microflow *property.ByNameRef[element.Element] +} + +// PageQualifiedName returns the value of the page property. +func (o *HomePageBase) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *HomePageBase) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *HomePageBase) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *HomePageBase) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *HomePageBase) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Page"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.page.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// HomePage +// ──────────────────────────────────────────────────────── + +type HomePage struct { + element.Base + page *property.ByNameRef[element.Element] + microflow *property.ByNameRef[element.Element] +} + +// PageQualifiedName returns the value of the page property. +func (o *HomePage) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *HomePage) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *HomePage) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *HomePage) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *HomePage) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Page"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.page.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// NativeHomePageBase +// ──────────────────────────────────────────────────────── + +type NativeHomePageBase struct { + element.Base + homePagePage *property.ByNameRef[element.Element] + homePageNanoflow *property.ByNameRef[element.Element] +} + +// HomePagePageQualifiedName returns the value of the homePagePage property. +func (o *NativeHomePageBase) HomePagePageQualifiedName() string { + return o.homePagePage.QualifiedName() +} + +// SetHomePagePageQualifiedName sets the value of the homePagePage property. +func (o *NativeHomePageBase) SetHomePagePageQualifiedName(v string) { + o.homePagePage.SetQualifiedName(v) +} + +// HomePageNanoflowQualifiedName returns the value of the homePageNanoflow property. +func (o *NativeHomePageBase) HomePageNanoflowQualifiedName() string { + return o.homePageNanoflow.QualifiedName() +} + +// SetHomePageNanoflowQualifiedName sets the value of the homePageNanoflow property. +func (o *NativeHomePageBase) SetHomePageNanoflowQualifiedName(v string) { + o.homePageNanoflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NativeHomePageBase) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("HomePagePage"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.homePagePage.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("HomePageNanoflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.homePageNanoflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// NativeHomePage +// ──────────────────────────────────────────────────────── + +type NativeHomePage struct { + element.Base + homePagePage *property.ByNameRef[element.Element] + homePageNanoflow *property.ByNameRef[element.Element] +} + +// HomePagePageQualifiedName returns the value of the homePagePage property. +func (o *NativeHomePage) HomePagePageQualifiedName() string { + return o.homePagePage.QualifiedName() +} + +// SetHomePagePageQualifiedName sets the value of the homePagePage property. +func (o *NativeHomePage) SetHomePagePageQualifiedName(v string) { + o.homePagePage.SetQualifiedName(v) +} + +// HomePageNanoflowQualifiedName returns the value of the homePageNanoflow property. +func (o *NativeHomePage) HomePageNanoflowQualifiedName() string { + return o.homePageNanoflow.QualifiedName() +} + +// SetHomePageNanoflowQualifiedName sets the value of the homePageNanoflow property. +func (o *NativeHomePage) SetHomePageNanoflowQualifiedName(v string) { + o.homePageNanoflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NativeHomePage) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("HomePagePage"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.homePagePage.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("HomePageNanoflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.homePageNanoflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// NavigationProfileBase +// ──────────────────────────────────────────────────────── + +type NavigationProfileBase struct { + element.Base + name *property.Primitive[string] + offlineEntityConfigs *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *NavigationProfileBase) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NavigationProfileBase) SetName(v string) { + o.name.Set(v) +} + +// OfflineEntityConfigsItems returns the value of the offlineEntityConfigs property. +func (o *NavigationProfileBase) OfflineEntityConfigsItems() []element.Element { + return o.offlineEntityConfigs.Items() +} + +// AddOfflineEntityConfigs appends a child element to the offlineEntityConfigs list. +func (o *NavigationProfileBase) AddOfflineEntityConfigs(v element.Element) { + o.offlineEntityConfigs.Append(v) +} + +// RemoveOfflineEntityConfigs removes the element at the given index from the offlineEntityConfigs list. +func (o *NavigationProfileBase) RemoveOfflineEntityConfigs(index int) { + o.offlineEntityConfigs.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NavigationProfileBase) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if children, err := codec.DecodeChildren(raw, "OfflineEntityConfigs"); err == nil { + for _, child := range children { + o.offlineEntityConfigs.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// NativeNavigationProfile +// ──────────────────────────────────────────────────────── + +type NativeNavigationProfile struct { + element.Base + name *property.Primitive[string] + offlineEntityConfigs *property.PartList[element.Element] + nativeHomePage *property.Part[element.Element] + homePage *property.ByNameRef[element.Element] + roleBasedNativeHomePages *property.PartList[element.Element] + bottomBarItems *property.PartList[element.Element] + otaEnabled *property.Primitive[bool] + loggingEnabled *property.Primitive[bool] + encryptionDbEnabled *property.Primitive[bool] + localFileEncryptionEnabled *property.Primitive[bool] + sessionCookieEncryptionEnabled *property.Primitive[bool] + screenNavigationTransition *property.Enum[string] + popupNavigationTransition *property.Enum[string] + applyScreenTransition *property.Primitive[bool] + hermesEnabled *property.Primitive[bool] + networkTimeoutMs *property.Primitive[int32] + nativeNavigationEnabled *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *NativeNavigationProfile) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NativeNavigationProfile) SetName(v string) { + o.name.Set(v) +} + +// OfflineEntityConfigsItems returns the value of the offlineEntityConfigs property. +func (o *NativeNavigationProfile) OfflineEntityConfigsItems() []element.Element { + return o.offlineEntityConfigs.Items() +} + +// AddOfflineEntityConfigs appends a child element to the offlineEntityConfigs list. +func (o *NativeNavigationProfile) AddOfflineEntityConfigs(v element.Element) { + o.offlineEntityConfigs.Append(v) +} + +// RemoveOfflineEntityConfigs removes the element at the given index from the offlineEntityConfigs list. +func (o *NativeNavigationProfile) RemoveOfflineEntityConfigs(index int) { + o.offlineEntityConfigs.Remove(index) +} + +// NativeHomePage returns the value of the nativeHomePage property. +func (o *NativeNavigationProfile) NativeHomePage() element.Element { + return o.nativeHomePage.Get() +} + +// SetNativeHomePage sets the value of the nativeHomePage property. +func (o *NativeNavigationProfile) SetNativeHomePage(v element.Element) { + o.nativeHomePage.Set(v) +} + +// HomePageQualifiedName returns the value of the homePage property. +func (o *NativeNavigationProfile) HomePageQualifiedName() string { + return o.homePage.QualifiedName() +} + +// SetHomePageQualifiedName sets the value of the homePage property. +func (o *NativeNavigationProfile) SetHomePageQualifiedName(v string) { + o.homePage.SetQualifiedName(v) +} + +// RoleBasedNativeHomePagesItems returns the value of the roleBasedNativeHomePages property. +func (o *NativeNavigationProfile) RoleBasedNativeHomePagesItems() []element.Element { + return o.roleBasedNativeHomePages.Items() +} + +// AddRoleBasedNativeHomePages appends a child element to the roleBasedNativeHomePages list. +func (o *NativeNavigationProfile) AddRoleBasedNativeHomePages(v element.Element) { + o.roleBasedNativeHomePages.Append(v) +} + +// RemoveRoleBasedNativeHomePages removes the element at the given index from the roleBasedNativeHomePages list. +func (o *NativeNavigationProfile) RemoveRoleBasedNativeHomePages(index int) { + o.roleBasedNativeHomePages.Remove(index) +} + +// BottomBarItemsItems returns the value of the bottomBarItems property. +func (o *NativeNavigationProfile) BottomBarItemsItems() []element.Element { + return o.bottomBarItems.Items() +} + +// AddBottomBarItems appends a child element to the bottomBarItems list. +func (o *NativeNavigationProfile) AddBottomBarItems(v element.Element) { + o.bottomBarItems.Append(v) +} + +// RemoveBottomBarItems removes the element at the given index from the bottomBarItems list. +func (o *NativeNavigationProfile) RemoveBottomBarItems(index int) { + o.bottomBarItems.Remove(index) +} + +// OtaEnabled returns the value of the otaEnabled property. +func (o *NativeNavigationProfile) OtaEnabled() bool { + return o.otaEnabled.Get() +} + +// SetOtaEnabled sets the value of the otaEnabled property. +func (o *NativeNavigationProfile) SetOtaEnabled(v bool) { + o.otaEnabled.Set(v) +} + +// LoggingEnabled returns the value of the loggingEnabled property. +func (o *NativeNavigationProfile) LoggingEnabled() bool { + return o.loggingEnabled.Get() +} + +// SetLoggingEnabled sets the value of the loggingEnabled property. +func (o *NativeNavigationProfile) SetLoggingEnabled(v bool) { + o.loggingEnabled.Set(v) +} + +// EncryptionDbEnabled returns the value of the encryptionDbEnabled property. +func (o *NativeNavigationProfile) EncryptionDbEnabled() bool { + return o.encryptionDbEnabled.Get() +} + +// SetEncryptionDbEnabled sets the value of the encryptionDbEnabled property. +func (o *NativeNavigationProfile) SetEncryptionDbEnabled(v bool) { + o.encryptionDbEnabled.Set(v) +} + +// LocalFileEncryptionEnabled returns the value of the localFileEncryptionEnabled property. +func (o *NativeNavigationProfile) LocalFileEncryptionEnabled() bool { + return o.localFileEncryptionEnabled.Get() +} + +// SetLocalFileEncryptionEnabled sets the value of the localFileEncryptionEnabled property. +func (o *NativeNavigationProfile) SetLocalFileEncryptionEnabled(v bool) { + o.localFileEncryptionEnabled.Set(v) +} + +// SessionCookieEncryptionEnabled returns the value of the sessionCookieEncryptionEnabled property. +func (o *NativeNavigationProfile) SessionCookieEncryptionEnabled() bool { + return o.sessionCookieEncryptionEnabled.Get() +} + +// SetSessionCookieEncryptionEnabled sets the value of the sessionCookieEncryptionEnabled property. +func (o *NativeNavigationProfile) SetSessionCookieEncryptionEnabled(v bool) { + o.sessionCookieEncryptionEnabled.Set(v) +} + +// ScreenNavigationTransition returns the value of the screenNavigationTransition property. +func (o *NativeNavigationProfile) ScreenNavigationTransition() string { + return o.screenNavigationTransition.Get() +} + +// SetScreenNavigationTransition sets the value of the screenNavigationTransition property. +func (o *NativeNavigationProfile) SetScreenNavigationTransition(v string) { + o.screenNavigationTransition.Set(v) +} + +// PopupNavigationTransition returns the value of the popupNavigationTransition property. +func (o *NativeNavigationProfile) PopupNavigationTransition() string { + return o.popupNavigationTransition.Get() +} + +// SetPopupNavigationTransition sets the value of the popupNavigationTransition property. +func (o *NativeNavigationProfile) SetPopupNavigationTransition(v string) { + o.popupNavigationTransition.Set(v) +} + +// ApplyScreenTransition returns the value of the applyScreenTransition property. +func (o *NativeNavigationProfile) ApplyScreenTransition() bool { + return o.applyScreenTransition.Get() +} + +// SetApplyScreenTransition sets the value of the applyScreenTransition property. +func (o *NativeNavigationProfile) SetApplyScreenTransition(v bool) { + o.applyScreenTransition.Set(v) +} + +// HermesEnabled returns the value of the hermesEnabled property. +func (o *NativeNavigationProfile) HermesEnabled() bool { + return o.hermesEnabled.Get() +} + +// SetHermesEnabled sets the value of the hermesEnabled property. +func (o *NativeNavigationProfile) SetHermesEnabled(v bool) { + o.hermesEnabled.Set(v) +} + +// NetworkTimeoutMs returns the value of the networkTimeoutMs property. +func (o *NativeNavigationProfile) NetworkTimeoutMs() int32 { + return o.networkTimeoutMs.Get() +} + +// SetNetworkTimeoutMs sets the value of the networkTimeoutMs property. +func (o *NativeNavigationProfile) SetNetworkTimeoutMs(v int32) { + o.networkTimeoutMs.Set(v) +} + +// NativeNavigationEnabled returns the value of the nativeNavigationEnabled property. +func (o *NativeNavigationProfile) NativeNavigationEnabled() bool { + return o.nativeNavigationEnabled.Get() +} + +// SetNativeNavigationEnabled sets the value of the nativeNavigationEnabled property. +func (o *NativeNavigationProfile) SetNativeNavigationEnabled(v bool) { + o.nativeNavigationEnabled.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NativeNavigationProfile) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if children, err := codec.DecodeChildren(raw, "OfflineEntityConfigs"); err == nil { + for _, child := range children { + o.offlineEntityConfigs.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "NativeHomePage"); err == nil { + o.nativeHomePage.SetFromDecode(child) + } + if val, err := raw.LookupErr("HomePage"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.homePage.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "RoleBasedNativeHomePages"); err == nil { + for _, child := range children { + o.roleBasedNativeHomePages.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "BottomBarItems"); err == nil { + for _, child := range children { + o.bottomBarItems.AppendFromDecode(child) + } + } + o.otaEnabled.Init(raw) + o.loggingEnabled.Init(raw) + o.encryptionDbEnabled.Init(raw) + o.localFileEncryptionEnabled.Init(raw) + o.sessionCookieEncryptionEnabled.Init(raw) + if val, err := raw.LookupErr("ScreenNavigationTransition"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.screenNavigationTransition.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PopupNavigationTransition"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.popupNavigationTransition.SetFromDecode(s) + } + } + o.applyScreenTransition.Init(raw) + o.hermesEnabled.Init(raw) + o.networkTimeoutMs.Init(raw) + o.nativeNavigationEnabled.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// NavigationDocument +// ──────────────────────────────────────────────────────── + +type NavigationDocument struct { + element.Base + profiles *property.PartList[element.Element] + phoneProfile *property.Part[element.Element] + tabletProfile *property.Part[element.Element] + desktopProfile *property.Part[element.Element] + hybridTabletProfile *property.Part[element.Element] + hybridPhoneProfile *property.Part[element.Element] + offlinePhoneProfile *property.Part[element.Element] + hybridPhoneProfile6 *property.Part[element.Element] + hybridTabletProfile6 *property.Part[element.Element] +} + +// ProfilesItems returns the value of the profiles property. +func (o *NavigationDocument) ProfilesItems() []element.Element { + return o.profiles.Items() +} + +// AddProfiles appends a child element to the profiles list. +func (o *NavigationDocument) AddProfiles(v element.Element) { + o.profiles.Append(v) +} + +// RemoveProfiles removes the element at the given index from the profiles list. +func (o *NavigationDocument) RemoveProfiles(index int) { + o.profiles.Remove(index) +} + +// PhoneProfile returns the value of the phoneProfile property. +func (o *NavigationDocument) PhoneProfile() element.Element { + return o.phoneProfile.Get() +} + +// SetPhoneProfile sets the value of the phoneProfile property. +func (o *NavigationDocument) SetPhoneProfile(v element.Element) { + o.phoneProfile.Set(v) +} + +// TabletProfile returns the value of the tabletProfile property. +func (o *NavigationDocument) TabletProfile() element.Element { + return o.tabletProfile.Get() +} + +// SetTabletProfile sets the value of the tabletProfile property. +func (o *NavigationDocument) SetTabletProfile(v element.Element) { + o.tabletProfile.Set(v) +} + +// DesktopProfile returns the value of the desktopProfile property. +func (o *NavigationDocument) DesktopProfile() element.Element { + return o.desktopProfile.Get() +} + +// SetDesktopProfile sets the value of the desktopProfile property. +func (o *NavigationDocument) SetDesktopProfile(v element.Element) { + o.desktopProfile.Set(v) +} + +// HybridTabletProfile returns the value of the hybridTabletProfile property. +func (o *NavigationDocument) HybridTabletProfile() element.Element { + return o.hybridTabletProfile.Get() +} + +// SetHybridTabletProfile sets the value of the hybridTabletProfile property. +func (o *NavigationDocument) SetHybridTabletProfile(v element.Element) { + o.hybridTabletProfile.Set(v) +} + +// HybridPhoneProfile returns the value of the hybridPhoneProfile property. +func (o *NavigationDocument) HybridPhoneProfile() element.Element { + return o.hybridPhoneProfile.Get() +} + +// SetHybridPhoneProfile sets the value of the hybridPhoneProfile property. +func (o *NavigationDocument) SetHybridPhoneProfile(v element.Element) { + o.hybridPhoneProfile.Set(v) +} + +// OfflinePhoneProfile returns the value of the offlinePhoneProfile property. +func (o *NavigationDocument) OfflinePhoneProfile() element.Element { + return o.offlinePhoneProfile.Get() +} + +// SetOfflinePhoneProfile sets the value of the offlinePhoneProfile property. +func (o *NavigationDocument) SetOfflinePhoneProfile(v element.Element) { + o.offlinePhoneProfile.Set(v) +} + +// HybridPhoneProfile6 returns the value of the hybridPhoneProfile6 property. +func (o *NavigationDocument) HybridPhoneProfile6() element.Element { + return o.hybridPhoneProfile6.Get() +} + +// SetHybridPhoneProfile6 sets the value of the hybridPhoneProfile6 property. +func (o *NavigationDocument) SetHybridPhoneProfile6(v element.Element) { + o.hybridPhoneProfile6.Set(v) +} + +// HybridTabletProfile6 returns the value of the hybridTabletProfile6 property. +func (o *NavigationDocument) HybridTabletProfile6() element.Element { + return o.hybridTabletProfile6.Get() +} + +// SetHybridTabletProfile6 sets the value of the hybridTabletProfile6 property. +func (o *NavigationDocument) SetHybridTabletProfile6(v element.Element) { + o.hybridTabletProfile6.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NavigationDocument) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Profiles"); err == nil { + for _, child := range children { + o.profiles.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "PhoneProfile"); err == nil { + o.phoneProfile.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TabletProfile"); err == nil { + o.tabletProfile.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DesktopProfile"); err == nil { + o.desktopProfile.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "HybridTabletProfile"); err == nil { + o.hybridTabletProfile.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "HybridPhoneProfile"); err == nil { + o.hybridPhoneProfile.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OfflinePhoneProfile"); err == nil { + o.offlinePhoneProfile.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "HybridPhoneProfile6"); err == nil { + o.hybridPhoneProfile6.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "HybridTabletProfile6"); err == nil { + o.hybridTabletProfile6.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NavigationProfile +// ──────────────────────────────────────────────────────── + +type NavigationProfile struct { + element.Base + name *property.Primitive[string] + offlineEntityConfigs *property.PartList[element.Element] + kind *property.Enum[string] + enabled *property.Primitive[bool] + offlineEnabled *property.Primitive[bool] + homePage *property.Part[element.Element] + roleBasedHomePages *property.PartList[element.Element] + applicationTitle *property.Primitive[string] + appTitle *property.Part[element.Element] + appIcon *property.ByNameRef[element.Element] + loginPageSettings *property.Part[element.Element] + menuItemCollection *property.Part[element.Element] + offlineEnabled6 *property.Primitive[bool] + progressiveWebAppSettings *property.Part[element.Element] + notFoundHomepage *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *NavigationProfile) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NavigationProfile) SetName(v string) { + o.name.Set(v) +} + +// OfflineEntityConfigsItems returns the value of the offlineEntityConfigs property. +func (o *NavigationProfile) OfflineEntityConfigsItems() []element.Element { + return o.offlineEntityConfigs.Items() +} + +// AddOfflineEntityConfigs appends a child element to the offlineEntityConfigs list. +func (o *NavigationProfile) AddOfflineEntityConfigs(v element.Element) { + o.offlineEntityConfigs.Append(v) +} + +// RemoveOfflineEntityConfigs removes the element at the given index from the offlineEntityConfigs list. +func (o *NavigationProfile) RemoveOfflineEntityConfigs(index int) { + o.offlineEntityConfigs.Remove(index) +} + +// Kind returns the value of the kind property. +func (o *NavigationProfile) Kind() string { + return o.kind.Get() +} + +// SetKind sets the value of the kind property. +func (o *NavigationProfile) SetKind(v string) { + o.kind.Set(v) +} + +// Enabled returns the value of the enabled property. +func (o *NavigationProfile) Enabled() bool { + return o.enabled.Get() +} + +// SetEnabled sets the value of the enabled property. +func (o *NavigationProfile) SetEnabled(v bool) { + o.enabled.Set(v) +} + +// OfflineEnabled returns the value of the offlineEnabled property. +func (o *NavigationProfile) OfflineEnabled() bool { + return o.offlineEnabled.Get() +} + +// SetOfflineEnabled sets the value of the offlineEnabled property. +func (o *NavigationProfile) SetOfflineEnabled(v bool) { + o.offlineEnabled.Set(v) +} + +// HomePage returns the value of the homePage property. +func (o *NavigationProfile) HomePage() element.Element { + return o.homePage.Get() +} + +// SetHomePage sets the value of the homePage property. +func (o *NavigationProfile) SetHomePage(v element.Element) { + o.homePage.Set(v) +} + +// RoleBasedHomePagesItems returns the value of the roleBasedHomePages property. +func (o *NavigationProfile) RoleBasedHomePagesItems() []element.Element { + return o.roleBasedHomePages.Items() +} + +// AddRoleBasedHomePages appends a child element to the roleBasedHomePages list. +func (o *NavigationProfile) AddRoleBasedHomePages(v element.Element) { + o.roleBasedHomePages.Append(v) +} + +// RemoveRoleBasedHomePages removes the element at the given index from the roleBasedHomePages list. +func (o *NavigationProfile) RemoveRoleBasedHomePages(index int) { + o.roleBasedHomePages.Remove(index) +} + +// ApplicationTitle returns the value of the applicationTitle property. +func (o *NavigationProfile) ApplicationTitle() string { + return o.applicationTitle.Get() +} + +// SetApplicationTitle sets the value of the applicationTitle property. +func (o *NavigationProfile) SetApplicationTitle(v string) { + o.applicationTitle.Set(v) +} + +// AppTitle returns the value of the appTitle property. +func (o *NavigationProfile) AppTitle() element.Element { + return o.appTitle.Get() +} + +// SetAppTitle sets the value of the appTitle property. +func (o *NavigationProfile) SetAppTitle(v element.Element) { + o.appTitle.Set(v) +} + +// AppIconQualifiedName returns the value of the appIcon property. +func (o *NavigationProfile) AppIconQualifiedName() string { + return o.appIcon.QualifiedName() +} + +// SetAppIconQualifiedName sets the value of the appIcon property. +func (o *NavigationProfile) SetAppIconQualifiedName(v string) { + o.appIcon.SetQualifiedName(v) +} + +// LoginPageSettings returns the value of the loginPageSettings property. +func (o *NavigationProfile) LoginPageSettings() element.Element { + return o.loginPageSettings.Get() +} + +// SetLoginPageSettings sets the value of the loginPageSettings property. +func (o *NavigationProfile) SetLoginPageSettings(v element.Element) { + o.loginPageSettings.Set(v) +} + +// MenuItemCollection returns the value of the menuItemCollection property. +func (o *NavigationProfile) MenuItemCollection() element.Element { + return o.menuItemCollection.Get() +} + +// SetMenuItemCollection sets the value of the menuItemCollection property. +func (o *NavigationProfile) SetMenuItemCollection(v element.Element) { + o.menuItemCollection.Set(v) +} + +// OfflineEnabled6 returns the value of the offlineEnabled6 property. +func (o *NavigationProfile) OfflineEnabled6() bool { + return o.offlineEnabled6.Get() +} + +// SetOfflineEnabled6 sets the value of the offlineEnabled6 property. +func (o *NavigationProfile) SetOfflineEnabled6(v bool) { + o.offlineEnabled6.Set(v) +} + +// ProgressiveWebAppSettings returns the value of the progressiveWebAppSettings property. +func (o *NavigationProfile) ProgressiveWebAppSettings() element.Element { + return o.progressiveWebAppSettings.Get() +} + +// SetProgressiveWebAppSettings sets the value of the progressiveWebAppSettings property. +func (o *NavigationProfile) SetProgressiveWebAppSettings(v element.Element) { + o.progressiveWebAppSettings.Set(v) +} + +// NotFoundHomepage returns the value of the notFoundHomepage property. +func (o *NavigationProfile) NotFoundHomepage() element.Element { + return o.notFoundHomepage.Get() +} + +// SetNotFoundHomepage sets the value of the notFoundHomepage property. +func (o *NavigationProfile) SetNotFoundHomepage(v element.Element) { + o.notFoundHomepage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NavigationProfile) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if children, err := codec.DecodeChildren(raw, "OfflineEntityConfigs"); err == nil { + for _, child := range children { + o.offlineEntityConfigs.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Kind"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.kind.SetFromDecode(s) + } + } + o.enabled.Init(raw) + o.offlineEnabled.Init(raw) + if child, err := codec.DecodeChild(raw, "HomePage"); err == nil { + o.homePage.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "HomeItems"); err == nil { + for _, child := range children { + o.roleBasedHomePages.AppendFromDecode(child) + } + } + o.applicationTitle.Init(raw) + if child, err := codec.DecodeChild(raw, "AppTitle"); err == nil { + o.appTitle.SetFromDecode(child) + } + if val, err := raw.LookupErr("AppIcon"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.appIcon.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "LoginPageSettings"); err == nil { + o.loginPageSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Menu"); err == nil { + o.menuItemCollection.SetFromDecode(child) + } + o.offlineEnabled6.Init(raw) + if child, err := codec.DecodeChild(raw, "ProgressiveWebAppSettings"); err == nil { + o.progressiveWebAppSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "NotFoundHomepage"); err == nil { + o.notFoundHomepage.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NotFoundHomePage +// ──────────────────────────────────────────────────────── + +type NotFoundHomePage struct { + element.Base + page *property.ByNameRef[element.Element] + microflow *property.ByNameRef[element.Element] +} + +// PageQualifiedName returns the value of the page property. +func (o *NotFoundHomePage) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *NotFoundHomePage) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *NotFoundHomePage) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *NotFoundHomePage) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NotFoundHomePage) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Page"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.page.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// OfflineEntityConfig +// ──────────────────────────────────────────────────────── + +type OfflineEntityConfig struct { + element.Base + entity *property.ByNameRef[element.Element] + downloadMode *property.Enum[string] + shouldDownload *property.Primitive[bool] + syncMode *property.Enum[string] + constraint *property.Primitive[string] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *OfflineEntityConfig) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *OfflineEntityConfig) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// DownloadMode returns the value of the downloadMode property. +func (o *OfflineEntityConfig) DownloadMode() string { + return o.downloadMode.Get() +} + +// SetDownloadMode sets the value of the downloadMode property. +func (o *OfflineEntityConfig) SetDownloadMode(v string) { + o.downloadMode.Set(v) +} + +// ShouldDownload returns the value of the shouldDownload property. +func (o *OfflineEntityConfig) ShouldDownload() bool { + return o.shouldDownload.Get() +} + +// SetShouldDownload sets the value of the shouldDownload property. +func (o *OfflineEntityConfig) SetShouldDownload(v bool) { + o.shouldDownload.Set(v) +} + +// SyncMode returns the value of the syncMode property. +func (o *OfflineEntityConfig) SyncMode() string { + return o.syncMode.Get() +} + +// SetSyncMode sets the value of the syncMode property. +func (o *OfflineEntityConfig) SetSyncMode(v string) { + o.syncMode.Set(v) +} + +// Constraint returns the value of the constraint property. +func (o *OfflineEntityConfig) Constraint() string { + return o.constraint.Get() +} + +// SetConstraint sets the value of the constraint property. +func (o *OfflineEntityConfig) SetConstraint(v string) { + o.constraint.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OfflineEntityConfig) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("DownloadMode"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.downloadMode.SetFromDecode(s) + } + } + o.shouldDownload.Init(raw) + if val, err := raw.LookupErr("SyncMode"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.syncMode.SetFromDecode(s) + } + } + o.constraint.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ProgressiveWebAppSettings +// ──────────────────────────────────────────────────────── + +type ProgressiveWebAppSettings struct { + element.Base + precaching *property.Primitive[bool] + installPrompt *property.Primitive[bool] +} + +// Precaching returns the value of the precaching property. +func (o *ProgressiveWebAppSettings) Precaching() bool { + return o.precaching.Get() +} + +// SetPrecaching sets the value of the precaching property. +func (o *ProgressiveWebAppSettings) SetPrecaching(v bool) { + o.precaching.Set(v) +} + +// InstallPrompt returns the value of the installPrompt property. +func (o *ProgressiveWebAppSettings) InstallPrompt() bool { + return o.installPrompt.Get() +} + +// SetInstallPrompt sets the value of the installPrompt property. +func (o *ProgressiveWebAppSettings) SetInstallPrompt(v bool) { + o.installPrompt.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ProgressiveWebAppSettings) InitFromRaw(raw bson.Raw) { + o.precaching.Init(raw) + o.installPrompt.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RoleBasedHomePage +// ──────────────────────────────────────────────────────── + +type RoleBasedHomePage struct { + element.Base + page *property.ByNameRef[element.Element] + microflow *property.ByNameRef[element.Element] + userRole *property.ByNameRef[element.Element] +} + +// PageQualifiedName returns the value of the page property. +func (o *RoleBasedHomePage) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *RoleBasedHomePage) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *RoleBasedHomePage) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *RoleBasedHomePage) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// UserRoleQualifiedName returns the value of the userRole property. +func (o *RoleBasedHomePage) UserRoleQualifiedName() string { + return o.userRole.QualifiedName() +} + +// SetUserRoleQualifiedName sets the value of the userRole property. +func (o *RoleBasedHomePage) SetUserRoleQualifiedName(v string) { + o.userRole.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RoleBasedHomePage) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Page"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.page.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("UserRole"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.userRole.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// RoleBasedNativeHomePage +// ──────────────────────────────────────────────────────── + +type RoleBasedNativeHomePage struct { + element.Base + homePagePage *property.ByNameRef[element.Element] + homePageNanoflow *property.ByNameRef[element.Element] + userRole *property.ByNameRef[element.Element] + page *property.ByNameRef[element.Element] +} + +// HomePagePageQualifiedName returns the value of the homePagePage property. +func (o *RoleBasedNativeHomePage) HomePagePageQualifiedName() string { + return o.homePagePage.QualifiedName() +} + +// SetHomePagePageQualifiedName sets the value of the homePagePage property. +func (o *RoleBasedNativeHomePage) SetHomePagePageQualifiedName(v string) { + o.homePagePage.SetQualifiedName(v) +} + +// HomePageNanoflowQualifiedName returns the value of the homePageNanoflow property. +func (o *RoleBasedNativeHomePage) HomePageNanoflowQualifiedName() string { + return o.homePageNanoflow.QualifiedName() +} + +// SetHomePageNanoflowQualifiedName sets the value of the homePageNanoflow property. +func (o *RoleBasedNativeHomePage) SetHomePageNanoflowQualifiedName(v string) { + o.homePageNanoflow.SetQualifiedName(v) +} + +// UserRoleQualifiedName returns the value of the userRole property. +func (o *RoleBasedNativeHomePage) UserRoleQualifiedName() string { + return o.userRole.QualifiedName() +} + +// SetUserRoleQualifiedName sets the value of the userRole property. +func (o *RoleBasedNativeHomePage) SetUserRoleQualifiedName(v string) { + o.userRole.SetQualifiedName(v) +} + +// PageQualifiedName returns the value of the page property. +func (o *RoleBasedNativeHomePage) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *RoleBasedNativeHomePage) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RoleBasedNativeHomePage) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("HomePagePage"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.homePagePage.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("HomePageNanoflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.homePageNanoflow.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("UserRole"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.userRole.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Page"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.page.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// NavigationProfileLoginFormSettings +// ──────────────────────────────────────────────────────── + +type NavigationProfileLoginFormSettings struct { + element.Base + loginPage *property.ByNameRef[element.Element] +} + +// LoginPageQualifiedName returns the value of the loginPage property. +func (o *NavigationProfileLoginFormSettings) LoginPageQualifiedName() string { + return o.loginPage.QualifiedName() +} + +// SetLoginPageQualifiedName sets the value of the loginPage property. +func (o *NavigationProfileLoginFormSettings) SetLoginPageQualifiedName(v string) { + o.loginPage.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NavigationProfileLoginFormSettings) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("LoginPage"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.loginPage.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initHomePage creates a HomePage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initHomePage() *HomePage { + o := &HomePage{} + o.SetTypeName("Navigation$HomePage") + o.page = property.NewByNameRef[element.Element]("Page", "Forms$Page") + o.page.Bind(&o.Base, 0) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.page, o.microflow}) + return o +} + +// NewHomePage creates a new HomePage for user code. Marked dirty (bit 63 = new element). +func NewHomePage() *HomePage { + o := initHomePage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNativeHomePage creates a NativeHomePage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNativeHomePage() *NativeHomePage { + o := &NativeHomePage{} + o.SetTypeName("Navigation$NativeHomePage") + o.homePagePage = property.NewByNameRef[element.Element]("HomePagePage", "Forms$Page") + o.homePagePage.Bind(&o.Base, 0) + o.homePageNanoflow = property.NewByNameRef[element.Element]("HomePageNanoflow", "Microflows$Nanoflow") + o.homePageNanoflow.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.homePagePage, o.homePageNanoflow}) + return o +} + +// NewNativeHomePage creates a new NativeHomePage for user code. Marked dirty (bit 63 = new element). +func NewNativeHomePage() *NativeHomePage { + o := initNativeHomePage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNativeNavigationProfile creates a NativeNavigationProfile with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNativeNavigationProfile() *NativeNavigationProfile { + o := &NativeNavigationProfile{} + o.SetTypeName("Navigation$NativeNavigationProfile") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.offlineEntityConfigs = property.NewPartList[element.Element]("OfflineEntityConfigs") + o.offlineEntityConfigs.Bind(&o.Base, 1) + o.nativeHomePage = property.NewPart[element.Element]("NativeHomePage") + o.nativeHomePage.Bind(&o.Base, 2) + o.homePage = property.NewByNameRef[element.Element]("HomePage", "Forms$Page") + o.homePage.Bind(&o.Base, 3) + o.roleBasedNativeHomePages = property.NewPartList[element.Element]("RoleBasedNativeHomePages") + o.roleBasedNativeHomePages.Bind(&o.Base, 4) + o.bottomBarItems = property.NewPartList[element.Element]("BottomBarItems") + o.bottomBarItems.Bind(&o.Base, 5) + o.otaEnabled = property.NewPrimitive[bool]("OtaEnabled", property.DecodeBool) + o.otaEnabled.Bind(&o.Base, 6) + o.loggingEnabled = property.NewPrimitive[bool]("LoggingEnabled", property.DecodeBool) + o.loggingEnabled.Bind(&o.Base, 7) + o.encryptionDbEnabled = property.NewPrimitive[bool]("EncryptionDbEnabled", property.DecodeBool) + o.encryptionDbEnabled.Bind(&o.Base, 8) + o.localFileEncryptionEnabled = property.NewPrimitive[bool]("LocalFileEncryptionEnabled", property.DecodeBool) + o.localFileEncryptionEnabled.Bind(&o.Base, 9) + o.sessionCookieEncryptionEnabled = property.NewPrimitive[bool]("SessionCookieEncryptionEnabled", property.DecodeBool) + o.sessionCookieEncryptionEnabled.Bind(&o.Base, 10) + o.screenNavigationTransition = property.NewEnum[string]("ScreenNavigationTransition") + o.screenNavigationTransition.Bind(&o.Base, 11) + o.popupNavigationTransition = property.NewEnum[string]("PopupNavigationTransition") + o.popupNavigationTransition.Bind(&o.Base, 12) + o.applyScreenTransition = property.NewPrimitive[bool]("ApplyScreenTransition", property.DecodeBool) + o.applyScreenTransition.Bind(&o.Base, 13) + o.hermesEnabled = property.NewPrimitive[bool]("HermesEnabled", property.DecodeBool) + o.hermesEnabled.Bind(&o.Base, 14) + o.networkTimeoutMs = property.NewPrimitive[int32]("NetworkTimeoutMs", property.DecodeInt32) + o.networkTimeoutMs.Bind(&o.Base, 15) + o.nativeNavigationEnabled = property.NewPrimitive[bool]("NativeNavigationEnabled", property.DecodeBool) + o.nativeNavigationEnabled.Bind(&o.Base, 16) + o.SetProperties([]element.Property{o.name, o.offlineEntityConfigs, o.nativeHomePage, o.homePage, o.roleBasedNativeHomePages, o.bottomBarItems, o.otaEnabled, o.loggingEnabled, o.encryptionDbEnabled, o.localFileEncryptionEnabled, o.sessionCookieEncryptionEnabled, o.screenNavigationTransition, o.popupNavigationTransition, o.applyScreenTransition, o.hermesEnabled, o.networkTimeoutMs, o.nativeNavigationEnabled}) + return o +} + +// NewNativeNavigationProfile creates a new NativeNavigationProfile for user code. Marked dirty (bit 63 = new element). +func NewNativeNavigationProfile() *NativeNavigationProfile { + o := initNativeNavigationProfile() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNavigationDocument creates a NavigationDocument with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNavigationDocument() *NavigationDocument { + o := &NavigationDocument{} + o.SetTypeName("Navigation$NavigationDocument") + o.profiles = property.NewPartList[element.Element]("Profiles") + o.profiles.Bind(&o.Base, 0) + o.phoneProfile = property.NewPart[element.Element]("PhoneProfile") + o.phoneProfile.Bind(&o.Base, 1) + o.tabletProfile = property.NewPart[element.Element]("TabletProfile") + o.tabletProfile.Bind(&o.Base, 2) + o.desktopProfile = property.NewPart[element.Element]("DesktopProfile") + o.desktopProfile.Bind(&o.Base, 3) + o.hybridTabletProfile = property.NewPart[element.Element]("HybridTabletProfile") + o.hybridTabletProfile.Bind(&o.Base, 4) + o.hybridPhoneProfile = property.NewPart[element.Element]("HybridPhoneProfile") + o.hybridPhoneProfile.Bind(&o.Base, 5) + o.offlinePhoneProfile = property.NewPart[element.Element]("OfflinePhoneProfile") + o.offlinePhoneProfile.Bind(&o.Base, 6) + o.hybridPhoneProfile6 = property.NewPart[element.Element]("HybridPhoneProfile6") + o.hybridPhoneProfile6.Bind(&o.Base, 7) + o.hybridTabletProfile6 = property.NewPart[element.Element]("HybridTabletProfile6") + o.hybridTabletProfile6.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.profiles, o.phoneProfile, o.tabletProfile, o.desktopProfile, o.hybridTabletProfile, o.hybridPhoneProfile, o.offlinePhoneProfile, o.hybridPhoneProfile6, o.hybridTabletProfile6}) + return o +} + +// NewNavigationDocument creates a new NavigationDocument for user code. Marked dirty (bit 63 = new element). +func NewNavigationDocument() *NavigationDocument { + o := initNavigationDocument() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNavigationProfile creates a NavigationProfile with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNavigationProfile() *NavigationProfile { + o := &NavigationProfile{} + o.SetTypeName("Navigation$NavigationProfile") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.offlineEntityConfigs = property.NewPartList[element.Element]("OfflineEntityConfigs") + o.offlineEntityConfigs.Bind(&o.Base, 1) + o.kind = property.NewEnum[string]("Kind") + o.kind.Bind(&o.Base, 2) + o.enabled = property.NewPrimitive[bool]("Enabled", property.DecodeBool) + o.enabled.Bind(&o.Base, 3) + o.offlineEnabled = property.NewPrimitive[bool]("OfflineEnabled", property.DecodeBool) + o.offlineEnabled.Bind(&o.Base, 4) + o.homePage = property.NewPart[element.Element]("HomePage") + o.homePage.Bind(&o.Base, 5) + o.roleBasedHomePages = property.NewPartList[element.Element]("HomeItems") + o.roleBasedHomePages.Bind(&o.Base, 6) + o.applicationTitle = property.NewPrimitive[string]("ApplicationTitle", property.DecodeString) + o.applicationTitle.Bind(&o.Base, 7) + o.appTitle = property.NewPart[element.Element]("AppTitle") + o.appTitle.Bind(&o.Base, 8) + o.appIcon = property.NewByNameRef[element.Element]("AppIcon", "Images$Image") + o.appIcon.Bind(&o.Base, 9) + o.loginPageSettings = property.NewPart[element.Element]("LoginPageSettings") + o.loginPageSettings.Bind(&o.Base, 10) + o.menuItemCollection = property.NewPart[element.Element]("Menu") + o.menuItemCollection.Bind(&o.Base, 11) + o.offlineEnabled6 = property.NewPrimitive[bool]("OfflineEnabled6", property.DecodeBool) + o.offlineEnabled6.Bind(&o.Base, 12) + o.progressiveWebAppSettings = property.NewPart[element.Element]("ProgressiveWebAppSettings") + o.progressiveWebAppSettings.Bind(&o.Base, 13) + o.notFoundHomepage = property.NewPart[element.Element]("NotFoundHomepage") + o.notFoundHomepage.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.name, o.offlineEntityConfigs, o.kind, o.enabled, o.offlineEnabled, o.homePage, o.roleBasedHomePages, o.applicationTitle, o.appTitle, o.appIcon, o.loginPageSettings, o.menuItemCollection, o.offlineEnabled6, o.progressiveWebAppSettings, o.notFoundHomepage}) + return o +} + +// NewNavigationProfile creates a new NavigationProfile for user code. Marked dirty (bit 63 = new element). +func NewNavigationProfile() *NavigationProfile { + o := initNavigationProfile() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNotFoundHomePage creates a NotFoundHomePage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNotFoundHomePage() *NotFoundHomePage { + o := &NotFoundHomePage{} + o.SetTypeName("Navigation$NotFoundHomePage") + o.page = property.NewByNameRef[element.Element]("Page", "Forms$Page") + o.page.Bind(&o.Base, 0) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.page, o.microflow}) + return o +} + +// NewNotFoundHomePage creates a new NotFoundHomePage for user code. Marked dirty (bit 63 = new element). +func NewNotFoundHomePage() *NotFoundHomePage { + o := initNotFoundHomePage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOfflineEntityConfig creates a OfflineEntityConfig with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOfflineEntityConfig() *OfflineEntityConfig { + o := &OfflineEntityConfig{} + o.SetTypeName("Navigation$OfflineEntityConfig") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.downloadMode = property.NewEnum[string]("DownloadMode") + o.downloadMode.Bind(&o.Base, 1) + o.shouldDownload = property.NewPrimitive[bool]("ShouldDownload", property.DecodeBool) + o.shouldDownload.Bind(&o.Base, 2) + o.syncMode = property.NewEnum[string]("SyncMode") + o.syncMode.Bind(&o.Base, 3) + o.constraint = property.NewPrimitive[string]("Constraint", property.DecodeString) + o.constraint.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.entity, o.downloadMode, o.shouldDownload, o.syncMode, o.constraint}) + return o +} + +// NewOfflineEntityConfig creates a new OfflineEntityConfig for user code. Marked dirty (bit 63 = new element). +func NewOfflineEntityConfig() *OfflineEntityConfig { + o := initOfflineEntityConfig() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initProgressiveWebAppSettings creates a ProgressiveWebAppSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initProgressiveWebAppSettings() *ProgressiveWebAppSettings { + o := &ProgressiveWebAppSettings{} + o.SetTypeName("Navigation$ProgressiveWebAppSettings") + o.precaching = property.NewPrimitive[bool]("Precaching", property.DecodeBool) + o.precaching.Bind(&o.Base, 0) + o.installPrompt = property.NewPrimitive[bool]("InstallPrompt", property.DecodeBool) + o.installPrompt.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.precaching, o.installPrompt}) + return o +} + +// NewProgressiveWebAppSettings creates a new ProgressiveWebAppSettings for user code. Marked dirty (bit 63 = new element). +func NewProgressiveWebAppSettings() *ProgressiveWebAppSettings { + o := initProgressiveWebAppSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRoleBasedHomePage creates a RoleBasedHomePage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRoleBasedHomePage() *RoleBasedHomePage { + o := &RoleBasedHomePage{} + o.SetTypeName("Navigation$RoleBasedHomePage") + o.page = property.NewByNameRef[element.Element]("Page", "Forms$Page") + o.page.Bind(&o.Base, 0) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 1) + o.userRole = property.NewByNameRef[element.Element]("UserRole", "Security$UserRole") + o.userRole.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.page, o.microflow, o.userRole}) + return o +} + +// NewRoleBasedHomePage creates a new RoleBasedHomePage for user code. Marked dirty (bit 63 = new element). +func NewRoleBasedHomePage() *RoleBasedHomePage { + o := initRoleBasedHomePage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRoleBasedNativeHomePage creates a RoleBasedNativeHomePage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRoleBasedNativeHomePage() *RoleBasedNativeHomePage { + o := &RoleBasedNativeHomePage{} + o.SetTypeName("Navigation$RoleBasedNativeHomePage") + o.homePagePage = property.NewByNameRef[element.Element]("HomePagePage", "Forms$Page") + o.homePagePage.Bind(&o.Base, 0) + o.homePageNanoflow = property.NewByNameRef[element.Element]("HomePageNanoflow", "Microflows$Nanoflow") + o.homePageNanoflow.Bind(&o.Base, 1) + o.userRole = property.NewByNameRef[element.Element]("UserRole", "Security$UserRole") + o.userRole.Bind(&o.Base, 2) + o.page = property.NewByNameRef[element.Element]("Page", "Forms$Page") + o.page.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.homePagePage, o.homePageNanoflow, o.userRole, o.page}) + return o +} + +// NewRoleBasedNativeHomePage creates a new RoleBasedNativeHomePage for user code. Marked dirty (bit 63 = new element). +func NewRoleBasedNativeHomePage() *RoleBasedNativeHomePage { + o := initRoleBasedNativeHomePage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNavigationProfileLoginFormSettings creates a NavigationProfileLoginFormSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNavigationProfileLoginFormSettings() *NavigationProfileLoginFormSettings { + o := &NavigationProfileLoginFormSettings{} + o.SetTypeName("Navigation$NavigationProfileLoginFormSettings") + o.loginPage = property.NewByNameRef[element.Element]("LoginPage", "Forms$Page") + o.loginPage.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.loginPage}) + return o +} + +// NewNavigationProfileLoginFormSettings creates a new NavigationProfileLoginFormSettings for user code. Marked dirty (bit 63 = new element). +func NewNavigationProfileLoginFormSettings() *NavigationProfileLoginFormSettings { + o := initNavigationProfileLoginFormSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Navigation$HomePage", func() element.Element { + return initHomePage() + }) + codec.DefaultRegistry.Register("Navigation$NativeHomePage", func() element.Element { + return initNativeHomePage() + }) + codec.DefaultRegistry.Register("Navigation$NativeNavigationProfile", func() element.Element { + return initNativeNavigationProfile() + }) + codec.DefaultRegistry.Register("Navigation$NavigationDocument", func() element.Element { + return initNavigationDocument() + }) + codec.DefaultRegistry.Register("Navigation$NavigationProfile", func() element.Element { + return initNavigationProfile() + }) + codec.DefaultRegistry.Register("Navigation$NotFoundHomePage", func() element.Element { + return initNotFoundHomePage() + }) + codec.DefaultRegistry.Register("Navigation$OfflineEntityConfig", func() element.Element { + return initOfflineEntityConfig() + }) + codec.DefaultRegistry.Register("Navigation$ProgressiveWebAppSettings", func() element.Element { + return initProgressiveWebAppSettings() + }) + codec.DefaultRegistry.Register("Navigation$RoleBasedHomePage", func() element.Element { + return initRoleBasedHomePage() + }) + codec.DefaultRegistry.Register("Navigation$RoleBasedNativeHomePage", func() element.Element { + return initRoleBasedNativeHomePage() + }) + codec.DefaultRegistry.Register("Navigation$NavigationProfileLoginFormSettings", func() element.Element { + return initNavigationProfileLoginFormSettings() + }) +} diff --git a/modelsdk/gen/navigation/version.go b/modelsdk/gen/navigation/version.go new file mode 100644 index 00000000..de0df60f --- /dev/null +++ b/modelsdk/gen/navigation/version.go @@ -0,0 +1,78 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package navigation + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Navigation$NavigationProfileBase": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Introduced: "7.2.0", Public: true}, + "offlineEntityConfigs": {Introduced: "7.22.0"}, + }, + }, + "Navigation$NativeNavigationProfile": { + Properties: map[string]version.PropertyVersionInfo{ + "applyScreenTransition": {Introduced: "10.11.0"}, + "bottomBarItems": {Introduced: "8.0.0"}, + "encryptionDbEnabled": {Introduced: "9.18.0"}, + "hermesEnabled": {Introduced: "10.11.0", Deleted: "10.18.0"}, + "homePage": {Deleted: "9.4.0"}, + "localFileEncryptionEnabled": {Introduced: "9.22.0"}, + "loggingEnabled": {Introduced: "9.15.0"}, + "nativeHomePage": {Introduced: "9.4.0", Required: true}, + "nativeNavigationEnabled": {Introduced: "11.1.0"}, + "networkTimeoutMs": {Introduced: "11.0.0"}, + "otaEnabled": {Introduced: "9.4.0"}, + "popupNavigationTransition": {Introduced: "10.11.0"}, + "roleBasedNativeHomePages": {Introduced: "8.0.0"}, + "screenNavigationTransition": {Introduced: "10.11.0"}, + "sessionCookieEncryptionEnabled": {Introduced: "10.21.0"}, + }, + }, + "Navigation$NavigationDocument": { + Properties: map[string]version.PropertyVersionInfo{ + "desktopProfile": {Deleted: "7.2.0", Required: true}, + "hybridPhoneProfile": {Introduced: "7.0.2", Deleted: "7.2.0", Required: true}, + "hybridPhoneProfile6": {Introduced: "6.10.4", Deleted: "7.0.0", Required: true}, + "hybridTabletProfile": {Introduced: "7.0.2", Deleted: "7.2.0", Required: true}, + "hybridTabletProfile6": {Introduced: "6.10.4", Deleted: "7.0.0", Required: true}, + "offlinePhoneProfile": {Deleted: "7.0.2", Required: true}, + "phoneProfile": {Deleted: "7.2.0", Required: true}, + "profiles": {Introduced: "7.2.0", Public: true}, + "tabletProfile": {Deleted: "7.2.0", Required: true}, + }, + }, + "Navigation$NavigationProfile": { + Properties: map[string]version.PropertyVersionInfo{ + "appIcon": {Introduced: "8.12.0"}, + "appTitle": {Introduced: "8.12.0", Required: true}, + "applicationTitle": {Deleted: "8.12.0"}, + "enabled": {Deleted: "7.2.0"}, + "homePage": {Required: true}, + "kind": {Introduced: "7.2.0"}, + "loginPageSettings": {Introduced: "7.0.2", Required: true}, + "menuItemCollection": {Required: true}, + "notFoundHomepage": {Introduced: "10.13.0"}, + "offlineEnabled": {Introduced: "7.0.2", Deleted: "7.2.0"}, + "offlineEnabled6": {Introduced: "6.10.4", Deleted: "7.0.0"}, + "progressiveWebAppSettings": {Introduced: "9.0.3"}, + }, + }, + "Navigation$OfflineEntityConfig": { + Properties: map[string]version.PropertyVersionInfo{ + "downloadMode": {Introduced: "8.9.0", Deleted: "9.24.0"}, + "entity": {Required: true}, + "shouldDownload": {Deleted: "8.9.0"}, + "syncMode": {Introduced: "9.24.0"}, + }, + }, + "Navigation$RoleBasedNativeHomePage": { + Properties: map[string]version.PropertyVersionInfo{ + "page": {Deleted: "9.4.0"}, + }, + }, +} diff --git a/modelsdk/gen/odatapublish/enums.go b/modelsdk/gen/odatapublish/enums.go new file mode 100644 index 00000000..e0a201c7 --- /dev/null +++ b/modelsdk/gen/odatapublish/enums.go @@ -0,0 +1,13 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package odatapublish + +// PublishedODataVersion enumerates the possible values for the PublishedODataVersion type. +type PublishedODataVersion = string + +const ( + PublishedODataVersionOData4 PublishedODataVersion = "OData4" + PublishedODataVersionOData3 PublishedODataVersion = "OData3" +) diff --git a/modelsdk/gen/odatapublish/refs.go b/modelsdk/gen/odatapublish/refs.go new file mode 100644 index 00000000..2a0d4d2b --- /dev/null +++ b/modelsdk/gen/odatapublish/refs.go @@ -0,0 +1,48 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package odatapublish + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$CallMicroflowToChange", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$CallMicroflowToRead", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$EntitySet", []codec.RefMeta{ + {Prop: "EntityType", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$EntityType", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$PublishedAssociationEnd", []codec.RefMeta{ + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$PublishedAttribute", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$PublishedEnumeration", []codec.RefMeta{ + {Prop: "Enumeration", Kind: codec.RefByName, Target: "Enumerations$Enumeration"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$PublishedEnumerationValue", []codec.RefMeta{ + {Prop: "EnumerationValue", Kind: codec.RefByName, Target: "Enumerations$EnumerationValue"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$PublishedMicroflow", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$PublishedMicroflowParameter", []codec.RefMeta{ + {Prop: "MicroflowParameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("ODataPublish$PublishedODataService2", []codec.RefMeta{ + {Prop: "AllowedModuleRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + {Prop: "AuthenticationMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("PublishedODataServices$PublishedODataMember", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) +} diff --git a/modelsdk/gen/odatapublish/types.go b/modelsdk/gen/odatapublish/types.go new file mode 100644 index 00000000..e505b05a --- /dev/null +++ b/modelsdk/gen/odatapublish/types.go @@ -0,0 +1,2347 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package odatapublish + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// ChangeMode +// ──────────────────────────────────────────────────────── + +type ChangeMode struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ChangeMode) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CallMicroflowToChange +// ──────────────────────────────────────────────────────── + +type CallMicroflowToChange struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *CallMicroflowToChange) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *CallMicroflowToChange) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CallMicroflowToChange) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ReadMode +// ──────────────────────────────────────────────────────── + +type ReadMode struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReadMode) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CallMicroflowToRead +// ──────────────────────────────────────────────────────── + +type CallMicroflowToRead struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *CallMicroflowToRead) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *CallMicroflowToRead) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CallMicroflowToRead) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ChangeNotSupported +// ──────────────────────────────────────────────────────── + +type ChangeNotSupported struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ChangeNotSupported) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ChangeSource +// ──────────────────────────────────────────────────────── + +type ChangeSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ChangeSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EntitySet +// ──────────────────────────────────────────────────────── + +type EntitySet struct { + element.Base + exposedName *property.Primitive[string] + alternativeExposedName *property.Primitive[string] + entityType *property.ByIdRef[element.Element] + usePaging *property.Primitive[bool] + pageSize *property.Primitive[int32] + updateMode *property.Part[element.Element] + insertMode *property.Part[element.Element] + deleteMode *property.Part[element.Element] + readMode *property.Part[element.Element] + queryOptions *property.Part[element.Element] +} + +// ExposedName returns the value of the exposedName property. +func (o *EntitySet) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *EntitySet) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// AlternativeExposedName returns the value of the alternativeExposedName property. +func (o *EntitySet) AlternativeExposedName() string { + return o.alternativeExposedName.Get() +} + +// SetAlternativeExposedName sets the value of the alternativeExposedName property. +func (o *EntitySet) SetAlternativeExposedName(v string) { + o.alternativeExposedName.Set(v) +} + +// EntityTypeRefID returns the value of the entityType property. +func (o *EntitySet) EntityTypeRefID() element.ID { + return o.entityType.RefID() +} + +// SetEntityTypeID sets the value of the entityType property. +func (o *EntitySet) SetEntityTypeID(v element.ID) { + o.entityType.SetID(v) +} + +// UsePaging returns the value of the usePaging property. +func (o *EntitySet) UsePaging() bool { + return o.usePaging.Get() +} + +// SetUsePaging sets the value of the usePaging property. +func (o *EntitySet) SetUsePaging(v bool) { + o.usePaging.Set(v) +} + +// PageSize returns the value of the pageSize property. +func (o *EntitySet) PageSize() int32 { + return o.pageSize.Get() +} + +// SetPageSize sets the value of the pageSize property. +func (o *EntitySet) SetPageSize(v int32) { + o.pageSize.Set(v) +} + +// UpdateMode returns the value of the updateMode property. +func (o *EntitySet) UpdateMode() element.Element { + return o.updateMode.Get() +} + +// SetUpdateMode sets the value of the updateMode property. +func (o *EntitySet) SetUpdateMode(v element.Element) { + o.updateMode.Set(v) +} + +// InsertMode returns the value of the insertMode property. +func (o *EntitySet) InsertMode() element.Element { + return o.insertMode.Get() +} + +// SetInsertMode sets the value of the insertMode property. +func (o *EntitySet) SetInsertMode(v element.Element) { + o.insertMode.Set(v) +} + +// DeleteMode returns the value of the deleteMode property. +func (o *EntitySet) DeleteMode() element.Element { + return o.deleteMode.Get() +} + +// SetDeleteMode sets the value of the deleteMode property. +func (o *EntitySet) SetDeleteMode(v element.Element) { + o.deleteMode.Set(v) +} + +// ReadMode returns the value of the readMode property. +func (o *EntitySet) ReadMode() element.Element { + return o.readMode.Get() +} + +// SetReadMode sets the value of the readMode property. +func (o *EntitySet) SetReadMode(v element.Element) { + o.readMode.Set(v) +} + +// QueryOptions returns the value of the queryOptions property. +func (o *EntitySet) QueryOptions() element.Element { + return o.queryOptions.Get() +} + +// SetQueryOptions sets the value of the queryOptions property. +func (o *EntitySet) SetQueryOptions(v element.Element) { + o.queryOptions.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntitySet) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + o.alternativeExposedName.Init(raw) + if val, err := raw.LookupErr("EntityType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entityType.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.entityType.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + o.usePaging.Init(raw) + o.pageSize.Init(raw) + if child, err := codec.DecodeChild(raw, "UpdateMode"); err == nil { + o.updateMode.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "InsertMode"); err == nil { + o.insertMode.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DeleteMode"); err == nil { + o.deleteMode.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ReadMode"); err == nil { + o.readMode.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "QueryOptions"); err == nil { + o.queryOptions.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// EntityType +// ──────────────────────────────────────────────────────── + +type EntityType struct { + element.Base + exposedName *property.Primitive[string] + entity *property.ByNameRef[element.Element] + childMembers *property.PartList[element.Element] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *EntityType) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *EntityType) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *EntityType) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *EntityType) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ChildMembersItems returns the value of the childMembers property. +func (o *EntityType) ChildMembersItems() []element.Element { + return o.childMembers.Items() +} + +// AddChildMembers appends a child element to the childMembers list. +func (o *EntityType) AddChildMembers(v element.Element) { + o.childMembers.Append(v) +} + +// RemoveChildMembers removes the element at the given index from the childMembers list. +func (o *EntityType) RemoveChildMembers(index int) { + o.childMembers.Remove(index) +} + +// Summary returns the value of the summary property. +func (o *EntityType) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *EntityType) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *EntityType) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *EntityType) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityType) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Members"); err == nil { + for _, child := range children { + o.childMembers.AppendFromDecode(child) + } + } + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedMember +// ──────────────────────────────────────────────────────── + +type PublishedMember struct { + element.Base + exposedName *property.Primitive[string] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedMember) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedMember) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedMember) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedMember) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedMember) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedMember) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedMember) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedAssociationEnd +// ──────────────────────────────────────────────────────── + +type PublishedAssociationEnd struct { + element.Base + exposedName *property.Primitive[string] + summary *property.Primitive[string] + description *property.Primitive[string] + association *property.ByNameRef[element.Element] + entity *property.ByNameRef[element.Element] + canBeEmpty *property.Primitive[bool] + exposedAssociationName *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedAssociationEnd) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedAssociationEnd) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedAssociationEnd) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedAssociationEnd) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedAssociationEnd) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedAssociationEnd) SetDescription(v string) { + o.description.Set(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *PublishedAssociationEnd) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *PublishedAssociationEnd) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *PublishedAssociationEnd) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *PublishedAssociationEnd) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// CanBeEmpty returns the value of the canBeEmpty property. +func (o *PublishedAssociationEnd) CanBeEmpty() bool { + return o.canBeEmpty.Get() +} + +// SetCanBeEmpty sets the value of the canBeEmpty property. +func (o *PublishedAssociationEnd) SetCanBeEmpty(v bool) { + o.canBeEmpty.Set(v) +} + +// ExposedAssociationName returns the value of the exposedAssociationName property. +func (o *PublishedAssociationEnd) ExposedAssociationName() string { + return o.exposedAssociationName.Get() +} + +// SetExposedAssociationName sets the value of the exposedAssociationName property. +func (o *PublishedAssociationEnd) SetExposedAssociationName(v string) { + o.exposedAssociationName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedAssociationEnd) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.association.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + o.canBeEmpty.Init(raw) + o.exposedAssociationName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedAttribute +// ──────────────────────────────────────────────────────── + +type PublishedAttribute struct { + element.Base + exposedName *property.Primitive[string] + summary *property.Primitive[string] + description *property.Primitive[string] + attribute *property.ByNameRef[element.Element] + canBeEmpty *property.Primitive[bool] + isPartOfKey *property.Primitive[bool] + filterable *property.Primitive[bool] + sortable *property.Primitive[bool] + enumerationAsString *property.Primitive[bool] + stringAsGuid *property.Primitive[bool] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedAttribute) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedAttribute) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedAttribute) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedAttribute) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedAttribute) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedAttribute) SetDescription(v string) { + o.description.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *PublishedAttribute) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *PublishedAttribute) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// CanBeEmpty returns the value of the canBeEmpty property. +func (o *PublishedAttribute) CanBeEmpty() bool { + return o.canBeEmpty.Get() +} + +// SetCanBeEmpty sets the value of the canBeEmpty property. +func (o *PublishedAttribute) SetCanBeEmpty(v bool) { + o.canBeEmpty.Set(v) +} + +// IsPartOfKey returns the value of the isPartOfKey property. +func (o *PublishedAttribute) IsPartOfKey() bool { + return o.isPartOfKey.Get() +} + +// SetIsPartOfKey sets the value of the isPartOfKey property. +func (o *PublishedAttribute) SetIsPartOfKey(v bool) { + o.isPartOfKey.Set(v) +} + +// Filterable returns the value of the filterable property. +func (o *PublishedAttribute) Filterable() bool { + return o.filterable.Get() +} + +// SetFilterable sets the value of the filterable property. +func (o *PublishedAttribute) SetFilterable(v bool) { + o.filterable.Set(v) +} + +// Sortable returns the value of the sortable property. +func (o *PublishedAttribute) Sortable() bool { + return o.sortable.Get() +} + +// SetSortable sets the value of the sortable property. +func (o *PublishedAttribute) SetSortable(v bool) { + o.sortable.Set(v) +} + +// EnumerationAsString returns the value of the enumerationAsString property. +func (o *PublishedAttribute) EnumerationAsString() bool { + return o.enumerationAsString.Get() +} + +// SetEnumerationAsString sets the value of the enumerationAsString property. +func (o *PublishedAttribute) SetEnumerationAsString(v bool) { + o.enumerationAsString.Set(v) +} + +// StringAsGuid returns the value of the stringAsGuid property. +func (o *PublishedAttribute) StringAsGuid() bool { + return o.stringAsGuid.Get() +} + +// SetStringAsGuid sets the value of the stringAsGuid property. +func (o *PublishedAttribute) SetStringAsGuid(v bool) { + o.stringAsGuid.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedAttribute) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } + o.canBeEmpty.Init(raw) + o.isPartOfKey.Init(raw) + o.filterable.Init(raw) + o.sortable.Init(raw) + o.enumerationAsString.Init(raw) + o.stringAsGuid.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedContract +// ──────────────────────────────────────────────────────── + +type PublishedContract struct { + element.Base + serviceFeed *property.Part[element.Element] + metadata *property.Primitive[string] + openApi *property.Primitive[string] + graphQL *property.Primitive[string] +} + +// ServiceFeed returns the value of the serviceFeed property. +func (o *PublishedContract) ServiceFeed() element.Element { + return o.serviceFeed.Get() +} + +// SetServiceFeed sets the value of the serviceFeed property. +func (o *PublishedContract) SetServiceFeed(v element.Element) { + o.serviceFeed.Set(v) +} + +// Metadata returns the value of the metadata property. +func (o *PublishedContract) Metadata() string { + return o.metadata.Get() +} + +// SetMetadata sets the value of the metadata property. +func (o *PublishedContract) SetMetadata(v string) { + o.metadata.Set(v) +} + +// OpenApi returns the value of the openApi property. +func (o *PublishedContract) OpenApi() string { + return o.openApi.Get() +} + +// SetOpenApi sets the value of the openApi property. +func (o *PublishedContract) SetOpenApi(v string) { + o.openApi.Set(v) +} + +// GraphQL returns the value of the graphQL property. +func (o *PublishedContract) GraphQL() string { + return o.graphQL.Get() +} + +// SetGraphQL sets the value of the graphQL property. +func (o *PublishedContract) SetGraphQL(v string) { + o.graphQL.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedContract) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "ServiceFeed"); err == nil { + o.serviceFeed.SetFromDecode(child) + } + o.metadata.Init(raw) + o.openApi.Init(raw) + o.graphQL.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedEnumeration +// ──────────────────────────────────────────────────────── + +type PublishedEnumeration struct { + element.Base + exposedName *property.Primitive[string] + enumeration *property.ByNameRef[element.Element] + values *property.PartList[element.Element] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedEnumeration) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedEnumeration) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// EnumerationQualifiedName returns the value of the enumeration property. +func (o *PublishedEnumeration) EnumerationQualifiedName() string { + return o.enumeration.QualifiedName() +} + +// SetEnumerationQualifiedName sets the value of the enumeration property. +func (o *PublishedEnumeration) SetEnumerationQualifiedName(v string) { + o.enumeration.SetQualifiedName(v) +} + +// ValuesItems returns the value of the values property. +func (o *PublishedEnumeration) ValuesItems() []element.Element { + return o.values.Items() +} + +// AddValues appends a child element to the values list. +func (o *PublishedEnumeration) AddValues(v element.Element) { + o.values.Append(v) +} + +// RemoveValues removes the element at the given index from the values list. +func (o *PublishedEnumeration) RemoveValues(index int) { + o.values.Remove(index) +} + +// Summary returns the value of the summary property. +func (o *PublishedEnumeration) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedEnumeration) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedEnumeration) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedEnumeration) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedEnumeration) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("Enumeration"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.enumeration.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Values"); err == nil { + for _, child := range children { + o.values.AppendFromDecode(child) + } + } + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedEnumerationValue +// ──────────────────────────────────────────────────────── + +type PublishedEnumerationValue struct { + element.Base + exposedName *property.Primitive[string] + enumerationValue *property.ByNameRef[element.Element] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedEnumerationValue) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedEnumerationValue) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// EnumerationValueQualifiedName returns the value of the enumerationValue property. +func (o *PublishedEnumerationValue) EnumerationValueQualifiedName() string { + return o.enumerationValue.QualifiedName() +} + +// SetEnumerationValueQualifiedName sets the value of the enumerationValue property. +func (o *PublishedEnumerationValue) SetEnumerationValueQualifiedName(v string) { + o.enumerationValue.SetQualifiedName(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedEnumerationValue) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedEnumerationValue) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedEnumerationValue) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedEnumerationValue) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedEnumerationValue) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("EnumerationValue"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.enumerationValue.SetFromDecode(s) + } + } + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedId +// ──────────────────────────────────────────────────────── + +type PublishedId struct { + element.Base + exposedName *property.Primitive[string] + summary *property.Primitive[string] + description *property.Primitive[string] + isPartOfKey *property.Primitive[bool] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedId) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedId) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedId) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedId) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedId) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedId) SetDescription(v string) { + o.description.Set(v) +} + +// IsPartOfKey returns the value of the isPartOfKey property. +func (o *PublishedId) IsPartOfKey() bool { + return o.isPartOfKey.Get() +} + +// SetIsPartOfKey sets the value of the isPartOfKey property. +func (o *PublishedId) SetIsPartOfKey(v bool) { + o.isPartOfKey.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedId) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) + o.isPartOfKey.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedMicroflow +// ──────────────────────────────────────────────────────── + +type PublishedMicroflow struct { + element.Base + exposedName *property.Primitive[string] + alternativeExposedName *property.Primitive[string] + microflow *property.ByNameRef[element.Element] + parameters *property.PartList[element.Element] + returnType *property.Part[element.Element] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedMicroflow) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedMicroflow) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// AlternativeExposedName returns the value of the alternativeExposedName property. +func (o *PublishedMicroflow) AlternativeExposedName() string { + return o.alternativeExposedName.Get() +} + +// SetAlternativeExposedName sets the value of the alternativeExposedName property. +func (o *PublishedMicroflow) SetAlternativeExposedName(v string) { + o.alternativeExposedName.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *PublishedMicroflow) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *PublishedMicroflow) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *PublishedMicroflow) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *PublishedMicroflow) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *PublishedMicroflow) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// ReturnType returns the value of the returnType property. +func (o *PublishedMicroflow) ReturnType() element.Element { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *PublishedMicroflow) SetReturnType(v element.Element) { + o.returnType.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedMicroflow) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedMicroflow) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedMicroflow) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedMicroflow) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedMicroflow) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + o.alternativeExposedName.Init(raw) + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ReturnType"); err == nil { + o.returnType.SetFromDecode(child) + } + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedMicroflowParameter +// ──────────────────────────────────────────────────────── + +type PublishedMicroflowParameter struct { + element.Base + exposedName *property.Primitive[string] + microflowParameter *property.ByNameRef[element.Element] + dataType *property.Part[element.Element] + canBeEmpty *property.Primitive[bool] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedMicroflowParameter) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedMicroflowParameter) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// MicroflowParameterQualifiedName returns the value of the microflowParameter property. +func (o *PublishedMicroflowParameter) MicroflowParameterQualifiedName() string { + return o.microflowParameter.QualifiedName() +} + +// SetMicroflowParameterQualifiedName sets the value of the microflowParameter property. +func (o *PublishedMicroflowParameter) SetMicroflowParameterQualifiedName(v string) { + o.microflowParameter.SetQualifiedName(v) +} + +// DataType returns the value of the dataType property. +func (o *PublishedMicroflowParameter) DataType() element.Element { + return o.dataType.Get() +} + +// SetDataType sets the value of the dataType property. +func (o *PublishedMicroflowParameter) SetDataType(v element.Element) { + o.dataType.Set(v) +} + +// CanBeEmpty returns the value of the canBeEmpty property. +func (o *PublishedMicroflowParameter) CanBeEmpty() bool { + return o.canBeEmpty.Get() +} + +// SetCanBeEmpty sets the value of the canBeEmpty property. +func (o *PublishedMicroflowParameter) SetCanBeEmpty(v bool) { + o.canBeEmpty.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedMicroflowParameter) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedMicroflowParameter) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedMicroflowParameter) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedMicroflowParameter) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedMicroflowParameter) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("MicroflowParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflowParameter.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "DataType"); err == nil { + o.dataType.SetFromDecode(child) + } + o.canBeEmpty.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedODataService2 +// ──────────────────────────────────────────────────────── + +type PublishedODataService2 struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + namespace *property.Primitive[string] + path *property.Primitive[string] + allowedModuleRoles *property.ByNameRefList[element.Element] + serviceName *property.Primitive[string] + entityTypes *property.PartList[element.Element] + entitySets *property.PartList[element.Element] + microflows *property.PartList[element.Element] + enumerations *property.PartList[element.Element] + publishAssociations *property.Primitive[bool] + version *property.Primitive[string] + authenticationMicroflow *property.ByNameRef[element.Element] + authenticationTypes *property.EnumList[string] + summary *property.Primitive[string] + description *property.Primitive[string] + replaceIllegalChars *property.Primitive[bool] + useGeneralization *property.Primitive[bool] + oDataVersion *property.Enum[string] + includeMetadataByDefault *property.Primitive[bool] + supportsGraphQL *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *PublishedODataService2) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedODataService2) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedODataService2) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedODataService2) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *PublishedODataService2) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *PublishedODataService2) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *PublishedODataService2) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *PublishedODataService2) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Namespace returns the value of the namespace property. +func (o *PublishedODataService2) Namespace() string { + return o.namespace.Get() +} + +// SetNamespace sets the value of the namespace property. +func (o *PublishedODataService2) SetNamespace(v string) { + o.namespace.Set(v) +} + +// Path returns the value of the path property. +func (o *PublishedODataService2) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *PublishedODataService2) SetPath(v string) { + o.path.Set(v) +} + +// AllowedModuleRolesQualifiedNames returns the value of the allowedModuleRoles property. +func (o *PublishedODataService2) AllowedModuleRolesQualifiedNames() []string { + return o.allowedModuleRoles.QualifiedNames() +} + +// SetAllowedModuleRolesQualifiedNames sets the value of the allowedModuleRoles property. +func (o *PublishedODataService2) SetAllowedModuleRolesQualifiedNames(v []string) { + o.allowedModuleRoles.SetQualifiedNames(v) +} + +// AddAllowedModuleRoles appends a child element to the allowedModuleRoles list. +func (o *PublishedODataService2) AddAllowedModuleRoles(v string) { + o.allowedModuleRoles.Append(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *PublishedODataService2) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *PublishedODataService2) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// EntityTypesItems returns the value of the entityTypes property. +func (o *PublishedODataService2) EntityTypesItems() []element.Element { + return o.entityTypes.Items() +} + +// AddEntityTypes appends a child element to the entityTypes list. +func (o *PublishedODataService2) AddEntityTypes(v element.Element) { + o.entityTypes.Append(v) +} + +// RemoveEntityTypes removes the element at the given index from the entityTypes list. +func (o *PublishedODataService2) RemoveEntityTypes(index int) { + o.entityTypes.Remove(index) +} + +// EntitySetsItems returns the value of the entitySets property. +func (o *PublishedODataService2) EntitySetsItems() []element.Element { + return o.entitySets.Items() +} + +// AddEntitySets appends a child element to the entitySets list. +func (o *PublishedODataService2) AddEntitySets(v element.Element) { + o.entitySets.Append(v) +} + +// RemoveEntitySets removes the element at the given index from the entitySets list. +func (o *PublishedODataService2) RemoveEntitySets(index int) { + o.entitySets.Remove(index) +} + +// MicroflowsItems returns the value of the microflows property. +func (o *PublishedODataService2) MicroflowsItems() []element.Element { + return o.microflows.Items() +} + +// AddMicroflows appends a child element to the microflows list. +func (o *PublishedODataService2) AddMicroflows(v element.Element) { + o.microflows.Append(v) +} + +// RemoveMicroflows removes the element at the given index from the microflows list. +func (o *PublishedODataService2) RemoveMicroflows(index int) { + o.microflows.Remove(index) +} + +// EnumerationsItems returns the value of the enumerations property. +func (o *PublishedODataService2) EnumerationsItems() []element.Element { + return o.enumerations.Items() +} + +// AddEnumerations appends a child element to the enumerations list. +func (o *PublishedODataService2) AddEnumerations(v element.Element) { + o.enumerations.Append(v) +} + +// RemoveEnumerations removes the element at the given index from the enumerations list. +func (o *PublishedODataService2) RemoveEnumerations(index int) { + o.enumerations.Remove(index) +} + +// PublishAssociations returns the value of the publishAssociations property. +func (o *PublishedODataService2) PublishAssociations() bool { + return o.publishAssociations.Get() +} + +// SetPublishAssociations sets the value of the publishAssociations property. +func (o *PublishedODataService2) SetPublishAssociations(v bool) { + o.publishAssociations.Set(v) +} + +// Version returns the value of the version property. +func (o *PublishedODataService2) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *PublishedODataService2) SetVersion(v string) { + o.version.Set(v) +} + +// AuthenticationMicroflowQualifiedName returns the value of the authenticationMicroflow property. +func (o *PublishedODataService2) AuthenticationMicroflowQualifiedName() string { + return o.authenticationMicroflow.QualifiedName() +} + +// SetAuthenticationMicroflowQualifiedName sets the value of the authenticationMicroflow property. +func (o *PublishedODataService2) SetAuthenticationMicroflowQualifiedName(v string) { + o.authenticationMicroflow.SetQualifiedName(v) +} + +// AuthenticationTypesItems returns the value of the authenticationTypes property. +func (o *PublishedODataService2) AuthenticationTypesItems() []string { + return o.authenticationTypes.Items() +} + +// AddAuthenticationTypes appends a child element to the authenticationTypes list. +func (o *PublishedODataService2) AddAuthenticationTypes(v string) { + o.authenticationTypes.Append(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedODataService2) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedODataService2) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedODataService2) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedODataService2) SetDescription(v string) { + o.description.Set(v) +} + +// ReplaceIllegalChars returns the value of the replaceIllegalChars property. +func (o *PublishedODataService2) ReplaceIllegalChars() bool { + return o.replaceIllegalChars.Get() +} + +// SetReplaceIllegalChars sets the value of the replaceIllegalChars property. +func (o *PublishedODataService2) SetReplaceIllegalChars(v bool) { + o.replaceIllegalChars.Set(v) +} + +// UseGeneralization returns the value of the useGeneralization property. +func (o *PublishedODataService2) UseGeneralization() bool { + return o.useGeneralization.Get() +} + +// SetUseGeneralization sets the value of the useGeneralization property. +func (o *PublishedODataService2) SetUseGeneralization(v bool) { + o.useGeneralization.Set(v) +} + +// ODataVersion returns the value of the oDataVersion property. +func (o *PublishedODataService2) ODataVersion() string { + return o.oDataVersion.Get() +} + +// SetODataVersion sets the value of the oDataVersion property. +func (o *PublishedODataService2) SetODataVersion(v string) { + o.oDataVersion.Set(v) +} + +// IncludeMetadataByDefault returns the value of the includeMetadataByDefault property. +func (o *PublishedODataService2) IncludeMetadataByDefault() bool { + return o.includeMetadataByDefault.Get() +} + +// SetIncludeMetadataByDefault sets the value of the includeMetadataByDefault property. +func (o *PublishedODataService2) SetIncludeMetadataByDefault(v bool) { + o.includeMetadataByDefault.Set(v) +} + +// SupportsGraphQL returns the value of the supportsGraphQL property. +func (o *PublishedODataService2) SupportsGraphQL() bool { + return o.supportsGraphQL.Get() +} + +// SetSupportsGraphQL sets the value of the supportsGraphQL property. +func (o *PublishedODataService2) SetSupportsGraphQL(v bool) { + o.supportsGraphQL.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedODataService2) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.namespace.Init(raw) + o.path.Init(raw) + if val, err := raw.LookupErr("AllowedModuleRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { + qnames = append(qnames, s) + } + } + o.allowedModuleRoles.SetFromDecode(qnames) + } + } + o.serviceName.Init(raw) + if children, err := codec.DecodeChildren(raw, "Entities"); err == nil { + for _, child := range children { + o.entityTypes.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "EntitySets"); err == nil { + for _, child := range children { + o.entitySets.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Microflows"); err == nil { + for _, child := range children { + o.microflows.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Enumerations"); err == nil { + for _, child := range children { + o.enumerations.AppendFromDecode(child) + } + } + o.publishAssociations.Init(raw) + o.version.Init(raw) + if val, err := raw.LookupErr("AuthenticationMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.authenticationMicroflow.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("AuthenticationTypes"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + items := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { + items = append(items, s) + } + } + o.authenticationTypes.SetFromDecode(items) + } + } + o.summary.Init(raw) + o.description.Init(raw) + o.replaceIllegalChars.Init(raw) + o.useGeneralization.Init(raw) + if val, err := raw.LookupErr("ODataVersion"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.oDataVersion.SetFromDecode(s) + } + } + o.includeMetadataByDefault.Init(raw) + o.supportsGraphQL.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// QueryOptions +// ──────────────────────────────────────────────────────── + +type QueryOptions struct { + element.Base + countable *property.Primitive[bool] + topSupported *property.Primitive[bool] + skipSupported *property.Primitive[bool] +} + +// Countable returns the value of the countable property. +func (o *QueryOptions) Countable() bool { + return o.countable.Get() +} + +// SetCountable sets the value of the countable property. +func (o *QueryOptions) SetCountable(v bool) { + o.countable.Set(v) +} + +// TopSupported returns the value of the topSupported property. +func (o *QueryOptions) TopSupported() bool { + return o.topSupported.Get() +} + +// SetTopSupported sets the value of the topSupported property. +func (o *QueryOptions) SetTopSupported(v bool) { + o.topSupported.Set(v) +} + +// SkipSupported returns the value of the skipSupported property. +func (o *QueryOptions) SkipSupported() bool { + return o.skipSupported.Get() +} + +// SetSkipSupported sets the value of the skipSupported property. +func (o *QueryOptions) SetSkipSupported(v bool) { + o.skipSupported.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueryOptions) InitFromRaw(raw bson.Raw) { + o.countable.Init(raw) + o.topSupported.Init(raw) + o.skipSupported.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ReadSource +// ──────────────────────────────────────────────────────── + +type ReadSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReadSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ServiceFeed +// ──────────────────────────────────────────────────────── + +type ServiceFeed struct { + element.Base + xml *property.Primitive[string] + json *property.Primitive[string] +} + +// Xml returns the value of the xml property. +func (o *ServiceFeed) Xml() string { + return o.xml.Get() +} + +// SetXml sets the value of the xml property. +func (o *ServiceFeed) SetXml(v string) { + o.xml.Set(v) +} + +// Json returns the value of the json property. +func (o *ServiceFeed) Json() string { + return o.json.Get() +} + +// SetJson sets the value of the json property. +func (o *ServiceFeed) SetJson(v string) { + o.json.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ServiceFeed) InitFromRaw(raw bson.Raw) { + o.xml.Init(raw) + o.json.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedODataMember +// ──────────────────────────────────────────────────────── + +type PublishedODataMember struct { + element.Base + exposedName *property.Primitive[string] + attribute *property.ByNameRef[element.Element] + name *property.Primitive[string] + filterable *property.Primitive[bool] + sortable *property.Primitive[bool] + isPartOfKey *property.Primitive[bool] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedODataMember) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedODataMember) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *PublishedODataMember) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *PublishedODataMember) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// Name returns the value of the name property. +func (o *PublishedODataMember) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedODataMember) SetName(v string) { + o.name.Set(v) +} + +// Filterable returns the value of the filterable property. +func (o *PublishedODataMember) Filterable() bool { + return o.filterable.Get() +} + +// SetFilterable sets the value of the filterable property. +func (o *PublishedODataMember) SetFilterable(v bool) { + o.filterable.Set(v) +} + +// Sortable returns the value of the sortable property. +func (o *PublishedODataMember) Sortable() bool { + return o.sortable.Get() +} + +// SetSortable sets the value of the sortable property. +func (o *PublishedODataMember) SetSortable(v bool) { + o.sortable.Set(v) +} + +// IsPartOfKey returns the value of the isPartOfKey property. +func (o *PublishedODataMember) IsPartOfKey() bool { + return o.isPartOfKey.Get() +} + +// SetIsPartOfKey sets the value of the isPartOfKey property. +func (o *PublishedODataMember) SetIsPartOfKey(v bool) { + o.isPartOfKey.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedODataMember) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } + o.name.Init(raw) + o.filterable.Init(raw) + o.sortable.Init(raw) + o.isPartOfKey.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConsumedODataServiceHeader +// ──────────────────────────────────────────────────────── + +type ConsumedODataServiceHeader struct { + element.Base + key *property.Primitive[string] + value *property.Primitive[string] +} + +// Key returns the value of the key property. +func (o *ConsumedODataServiceHeader) Key() string { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *ConsumedODataServiceHeader) SetKey(v string) { + o.key.Set(v) +} + +// Value returns the value of the value property. +func (o *ConsumedODataServiceHeader) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *ConsumedODataServiceHeader) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConsumedODataServiceHeader) InitFromRaw(raw bson.Raw) { + o.key.Init(raw) + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initCallMicroflowToChange creates a CallMicroflowToChange with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCallMicroflowToChange() *CallMicroflowToChange { + o := &CallMicroflowToChange{} + o.SetTypeName("ODataPublish$CallMicroflowToChange") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow}) + return o +} + +// NewCallMicroflowToChange creates a new CallMicroflowToChange for user code. Marked dirty (bit 63 = new element). +func NewCallMicroflowToChange() *CallMicroflowToChange { + o := initCallMicroflowToChange() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCallMicroflowToRead creates a CallMicroflowToRead with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCallMicroflowToRead() *CallMicroflowToRead { + o := &CallMicroflowToRead{} + o.SetTypeName("ODataPublish$CallMicroflowToRead") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow}) + return o +} + +// NewCallMicroflowToRead creates a new CallMicroflowToRead for user code. Marked dirty (bit 63 = new element). +func NewCallMicroflowToRead() *CallMicroflowToRead { + o := initCallMicroflowToRead() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initChangeNotSupported creates a ChangeNotSupported with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initChangeNotSupported() *ChangeNotSupported { + o := &ChangeNotSupported{} + o.SetTypeName("ODataPublish$ChangeNotSupported") + o.SetProperties([]element.Property{}) + return o +} + +// NewChangeNotSupported creates a new ChangeNotSupported for user code. Marked dirty (bit 63 = new element). +func NewChangeNotSupported() *ChangeNotSupported { + o := initChangeNotSupported() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initChangeSource creates a ChangeSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initChangeSource() *ChangeSource { + o := &ChangeSource{} + o.SetTypeName("ODataPublish$ChangeSource") + o.SetProperties([]element.Property{}) + return o +} + +// NewChangeSource creates a new ChangeSource for user code. Marked dirty (bit 63 = new element). +func NewChangeSource() *ChangeSource { + o := initChangeSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntitySet creates a EntitySet with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntitySet() *EntitySet { + o := &EntitySet{} + o.SetTypeName("ODataPublish$EntitySet") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.alternativeExposedName = property.NewPrimitive[string]("AlternativeExposedName", property.DecodeString) + o.alternativeExposedName.Bind(&o.Base, 1) + o.entityType = property.NewByIdRef[element.Element]("EntityType") + o.entityType.Bind(&o.Base, 2) + o.usePaging = property.NewPrimitive[bool]("UsePaging", property.DecodeBool) + o.usePaging.Bind(&o.Base, 3) + o.pageSize = property.NewPrimitive[int32]("PageSize", property.DecodeInt32) + o.pageSize.Bind(&o.Base, 4) + o.updateMode = property.NewPart[element.Element]("UpdateMode") + o.updateMode.Bind(&o.Base, 5) + o.insertMode = property.NewPart[element.Element]("InsertMode") + o.insertMode.Bind(&o.Base, 6) + o.deleteMode = property.NewPart[element.Element]("DeleteMode") + o.deleteMode.Bind(&o.Base, 7) + o.readMode = property.NewPart[element.Element]("ReadMode") + o.readMode.Bind(&o.Base, 8) + o.queryOptions = property.NewPart[element.Element]("QueryOptions") + o.queryOptions.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.exposedName, o.alternativeExposedName, o.entityType, o.usePaging, o.pageSize, o.updateMode, o.insertMode, o.deleteMode, o.readMode, o.queryOptions}) + return o +} + +// NewEntitySet creates a new EntitySet for user code. Marked dirty (bit 63 = new element). +func NewEntitySet() *EntitySet { + o := initEntitySet() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEntityType creates a EntityType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEntityType() *EntityType { + o := &EntityType{} + o.SetTypeName("ODataPublish$EntityType") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 1) + o.childMembers = property.NewPartList[element.Element]("Members") + o.childMembers.Bind(&o.Base, 2) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 3) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.exposedName, o.entity, o.childMembers, o.summary, o.description}) + return o +} + +// NewEntityType creates a new EntityType for user code. Marked dirty (bit 63 = new element). +func NewEntityType() *EntityType { + o := initEntityType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedAssociationEnd creates a PublishedAssociationEnd with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedAssociationEnd() *PublishedAssociationEnd { + o := &PublishedAssociationEnd{} + o.SetTypeName("ODataPublish$PublishedAssociationEnd") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 3) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 4) + o.canBeEmpty = property.NewPrimitive[bool]("CanBeEmpty", property.DecodeBool) + o.canBeEmpty.Bind(&o.Base, 5) + o.exposedAssociationName = property.NewPrimitive[string]("ExposedAssociationName", property.DecodeString) + o.exposedAssociationName.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.exposedName, o.summary, o.description, o.association, o.entity, o.canBeEmpty, o.exposedAssociationName}) + return o +} + +// NewPublishedAssociationEnd creates a new PublishedAssociationEnd for user code. Marked dirty (bit 63 = new element). +func NewPublishedAssociationEnd() *PublishedAssociationEnd { + o := initPublishedAssociationEnd() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedAttribute creates a PublishedAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedAttribute() *PublishedAttribute { + o := &PublishedAttribute{} + o.SetTypeName("ODataPublish$PublishedAttribute") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 3) + o.canBeEmpty = property.NewPrimitive[bool]("CanBeEmpty", property.DecodeBool) + o.canBeEmpty.Bind(&o.Base, 4) + o.isPartOfKey = property.NewPrimitive[bool]("IsPartOfKey", property.DecodeBool) + o.isPartOfKey.Bind(&o.Base, 5) + o.filterable = property.NewPrimitive[bool]("Filterable", property.DecodeBool) + o.filterable.Bind(&o.Base, 6) + o.sortable = property.NewPrimitive[bool]("Sortable", property.DecodeBool) + o.sortable.Bind(&o.Base, 7) + o.enumerationAsString = property.NewPrimitive[bool]("EnumerationAsString", property.DecodeBool) + o.enumerationAsString.Bind(&o.Base, 8) + o.stringAsGuid = property.NewPrimitive[bool]("StringAsGuid", property.DecodeBool) + o.stringAsGuid.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.exposedName, o.summary, o.description, o.attribute, o.canBeEmpty, o.isPartOfKey, o.filterable, o.sortable, o.enumerationAsString, o.stringAsGuid}) + return o +} + +// NewPublishedAttribute creates a new PublishedAttribute for user code. Marked dirty (bit 63 = new element). +func NewPublishedAttribute() *PublishedAttribute { + o := initPublishedAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedContract creates a PublishedContract with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedContract() *PublishedContract { + o := &PublishedContract{} + o.SetTypeName("ODataPublish$PublishedContract") + o.serviceFeed = property.NewPart[element.Element]("ServiceFeed") + o.serviceFeed.Bind(&o.Base, 0) + o.metadata = property.NewPrimitive[string]("Metadata", property.DecodeString) + o.metadata.Bind(&o.Base, 1) + o.openApi = property.NewPrimitive[string]("OpenApi", property.DecodeString) + o.openApi.Bind(&o.Base, 2) + o.graphQL = property.NewPrimitive[string]("GraphQL", property.DecodeString) + o.graphQL.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.serviceFeed, o.metadata, o.openApi, o.graphQL}) + return o +} + +// NewPublishedContract creates a new PublishedContract for user code. Marked dirty (bit 63 = new element). +func NewPublishedContract() *PublishedContract { + o := initPublishedContract() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedEnumeration creates a PublishedEnumeration with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedEnumeration() *PublishedEnumeration { + o := &PublishedEnumeration{} + o.SetTypeName("ODataPublish$PublishedEnumeration") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.enumeration = property.NewByNameRef[element.Element]("Enumeration", "Enumerations$Enumeration") + o.enumeration.Bind(&o.Base, 1) + o.values = property.NewPartList[element.Element]("Values") + o.values.Bind(&o.Base, 2) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 3) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.exposedName, o.enumeration, o.values, o.summary, o.description}) + return o +} + +// NewPublishedEnumeration creates a new PublishedEnumeration for user code. Marked dirty (bit 63 = new element). +func NewPublishedEnumeration() *PublishedEnumeration { + o := initPublishedEnumeration() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedEnumerationValue creates a PublishedEnumerationValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedEnumerationValue() *PublishedEnumerationValue { + o := &PublishedEnumerationValue{} + o.SetTypeName("ODataPublish$PublishedEnumerationValue") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.enumerationValue = property.NewByNameRef[element.Element]("EnumerationValue", "Enumerations$EnumerationValue") + o.enumerationValue.Bind(&o.Base, 1) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 2) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.exposedName, o.enumerationValue, o.summary, o.description}) + return o +} + +// NewPublishedEnumerationValue creates a new PublishedEnumerationValue for user code. Marked dirty (bit 63 = new element). +func NewPublishedEnumerationValue() *PublishedEnumerationValue { + o := initPublishedEnumerationValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedId creates a PublishedId with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedId() *PublishedId { + o := &PublishedId{} + o.SetTypeName("ODataPublish$PublishedId") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.isPartOfKey = property.NewPrimitive[bool]("IsPartOfKey", property.DecodeBool) + o.isPartOfKey.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.exposedName, o.summary, o.description, o.isPartOfKey}) + return o +} + +// NewPublishedId creates a new PublishedId for user code. Marked dirty (bit 63 = new element). +func NewPublishedId() *PublishedId { + o := initPublishedId() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedMicroflow creates a PublishedMicroflow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedMicroflow() *PublishedMicroflow { + o := &PublishedMicroflow{} + o.SetTypeName("ODataPublish$PublishedMicroflow") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.alternativeExposedName = property.NewPrimitive[string]("AlternativeExposedName", property.DecodeString) + o.alternativeExposedName.Bind(&o.Base, 1) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 2) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 3) + o.returnType = property.NewPart[element.Element]("ReturnType") + o.returnType.Bind(&o.Base, 4) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 5) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.exposedName, o.alternativeExposedName, o.microflow, o.parameters, o.returnType, o.summary, o.description}) + return o +} + +// NewPublishedMicroflow creates a new PublishedMicroflow for user code. Marked dirty (bit 63 = new element). +func NewPublishedMicroflow() *PublishedMicroflow { + o := initPublishedMicroflow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedMicroflowParameter creates a PublishedMicroflowParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedMicroflowParameter() *PublishedMicroflowParameter { + o := &PublishedMicroflowParameter{} + o.SetTypeName("ODataPublish$PublishedMicroflowParameter") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.microflowParameter = property.NewByNameRef[element.Element]("MicroflowParameter", "Microflows$MicroflowParameter") + o.microflowParameter.Bind(&o.Base, 1) + o.dataType = property.NewPart[element.Element]("DataType") + o.dataType.Bind(&o.Base, 2) + o.canBeEmpty = property.NewPrimitive[bool]("CanBeEmpty", property.DecodeBool) + o.canBeEmpty.Bind(&o.Base, 3) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 4) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.exposedName, o.microflowParameter, o.dataType, o.canBeEmpty, o.summary, o.description}) + return o +} + +// NewPublishedMicroflowParameter creates a new PublishedMicroflowParameter for user code. Marked dirty (bit 63 = new element). +func NewPublishedMicroflowParameter() *PublishedMicroflowParameter { + o := initPublishedMicroflowParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedODataService2 creates a PublishedODataService2 with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedODataService2() *PublishedODataService2 { + o := &PublishedODataService2{} + o.SetTypeName("ODataPublish$PublishedODataService2") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.namespace = property.NewPrimitive[string]("Namespace", property.DecodeString) + o.namespace.Bind(&o.Base, 4) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 5) + o.allowedModuleRoles = property.NewByNameRefList[element.Element]("AllowedModuleRoles", "Security$ModuleRole") + o.allowedModuleRoles.Bind(&o.Base, 6) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 7) + o.entityTypes = property.NewPartList[element.Element]("Entities") + o.entityTypes.Bind(&o.Base, 8) + o.entitySets = property.NewPartList[element.Element]("EntitySets") + o.entitySets.Bind(&o.Base, 9) + o.microflows = property.NewPartList[element.Element]("Microflows") + o.microflows.Bind(&o.Base, 10) + o.enumerations = property.NewPartList[element.Element]("Enumerations") + o.enumerations.Bind(&o.Base, 11) + o.publishAssociations = property.NewPrimitive[bool]("PublishAssociations", property.DecodeBool) + o.publishAssociations.Bind(&o.Base, 12) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 13) + o.authenticationMicroflow = property.NewByNameRef[element.Element]("AuthenticationMicroflow", "Microflows$Microflow") + o.authenticationMicroflow.Bind(&o.Base, 14) + o.authenticationTypes = property.NewEnumList[string]("AuthenticationTypes") + o.authenticationTypes.Bind(&o.Base, 15) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 16) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 17) + o.replaceIllegalChars = property.NewPrimitive[bool]("ReplaceIllegalChars", property.DecodeBool) + o.replaceIllegalChars.Bind(&o.Base, 18) + o.useGeneralization = property.NewPrimitive[bool]("UseGeneralization", property.DecodeBool) + o.useGeneralization.Bind(&o.Base, 19) + o.oDataVersion = property.NewEnum[string]("ODataVersion") + o.oDataVersion.Bind(&o.Base, 20) + o.includeMetadataByDefault = property.NewPrimitive[bool]("IncludeMetadataByDefault", property.DecodeBool) + o.includeMetadataByDefault.Bind(&o.Base, 21) + o.supportsGraphQL = property.NewPrimitive[bool]("SupportsGraphQL", property.DecodeBool) + o.supportsGraphQL.Bind(&o.Base, 22) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.namespace, o.path, o.allowedModuleRoles, o.serviceName, o.entityTypes, o.entitySets, o.microflows, o.enumerations, o.publishAssociations, o.version, o.authenticationMicroflow, o.authenticationTypes, o.summary, o.description, o.replaceIllegalChars, o.useGeneralization, o.oDataVersion, o.includeMetadataByDefault, o.supportsGraphQL}) + return o +} + +// NewPublishedODataService2 creates a new PublishedODataService2 for user code. Marked dirty (bit 63 = new element). +func NewPublishedODataService2() *PublishedODataService2 { + o := initPublishedODataService2() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initQueryOptions creates a QueryOptions with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initQueryOptions() *QueryOptions { + o := &QueryOptions{} + o.SetTypeName("ODataPublish$QueryOptions") + o.countable = property.NewPrimitive[bool]("Countable", property.DecodeBool) + o.countable.Bind(&o.Base, 0) + o.topSupported = property.NewPrimitive[bool]("TopSupported", property.DecodeBool) + o.topSupported.Bind(&o.Base, 1) + o.skipSupported = property.NewPrimitive[bool]("SkipSupported", property.DecodeBool) + o.skipSupported.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.countable, o.topSupported, o.skipSupported}) + return o +} + +// NewQueryOptions creates a new QueryOptions for user code. Marked dirty (bit 63 = new element). +func NewQueryOptions() *QueryOptions { + o := initQueryOptions() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReadSource creates a ReadSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReadSource() *ReadSource { + o := &ReadSource{} + o.SetTypeName("ODataPublish$ReadSource") + o.SetProperties([]element.Property{}) + return o +} + +// NewReadSource creates a new ReadSource for user code. Marked dirty (bit 63 = new element). +func NewReadSource() *ReadSource { + o := initReadSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initServiceFeed creates a ServiceFeed with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initServiceFeed() *ServiceFeed { + o := &ServiceFeed{} + o.SetTypeName("ODataPublish$ServiceFeed") + o.xml = property.NewPrimitive[string]("Xml", property.DecodeString) + o.xml.Bind(&o.Base, 0) + o.json = property.NewPrimitive[string]("Json", property.DecodeString) + o.json.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.xml, o.json}) + return o +} + +// NewServiceFeed creates a new ServiceFeed for user code. Marked dirty (bit 63 = new element). +func NewServiceFeed() *ServiceFeed { + o := initServiceFeed() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedODataMember creates a PublishedODataMember with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedODataMember() *PublishedODataMember { + o := &PublishedODataMember{} + o.SetTypeName("PublishedODataServices$PublishedODataMember") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 1) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 2) + o.filterable = property.NewPrimitive[bool]("Filterable", property.DecodeBool) + o.filterable.Bind(&o.Base, 3) + o.sortable = property.NewPrimitive[bool]("Sortable", property.DecodeBool) + o.sortable.Bind(&o.Base, 4) + o.isPartOfKey = property.NewPrimitive[bool]("IsPartOfKey", property.DecodeBool) + o.isPartOfKey.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.exposedName, o.attribute, o.name, o.filterable, o.sortable, o.isPartOfKey}) + return o +} + +// NewPublishedODataMember creates a new PublishedODataMember for user code. Marked dirty (bit 63 = new element). +func NewPublishedODataMember() *PublishedODataMember { + o := initPublishedODataMember() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConsumedODataServiceHeader creates a ConsumedODataServiceHeader with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConsumedODataServiceHeader() *ConsumedODataServiceHeader { + o := &ConsumedODataServiceHeader{} + o.SetTypeName("ConsumedODataServices$ConsumedODataServiceHeader") + o.key = property.NewPrimitive[string]("Key", property.DecodeString) + o.key.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.key, o.value}) + return o +} + +// NewConsumedODataServiceHeader creates a new ConsumedODataServiceHeader for user code. Marked dirty (bit 63 = new element). +func NewConsumedODataServiceHeader() *ConsumedODataServiceHeader { + o := initConsumedODataServiceHeader() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("ODataPublish$CallMicroflowToChange", func() element.Element { + return initCallMicroflowToChange() + }) + codec.DefaultRegistry.Register("ODataPublish$CallMicroflowToRead", func() element.Element { + return initCallMicroflowToRead() + }) + codec.DefaultRegistry.Register("ODataPublish$ChangeNotSupported", func() element.Element { + return initChangeNotSupported() + }) + codec.DefaultRegistry.Register("ODataPublish$ChangeSource", func() element.Element { + return initChangeSource() + }) + codec.DefaultRegistry.Register("ODataPublish$EntitySet", func() element.Element { + return initEntitySet() + }) + codec.DefaultRegistry.Register("ODataPublish$EntityType", func() element.Element { + return initEntityType() + }) + codec.DefaultRegistry.Register("ODataPublish$PublishedAssociationEnd", func() element.Element { + return initPublishedAssociationEnd() + }) + codec.DefaultRegistry.Register("ODataPublish$PublishedAttribute", func() element.Element { + return initPublishedAttribute() + }) + codec.DefaultRegistry.Register("ODataPublish$PublishedContract", func() element.Element { + return initPublishedContract() + }) + codec.DefaultRegistry.Register("ODataPublish$PublishedEnumeration", func() element.Element { + return initPublishedEnumeration() + }) + codec.DefaultRegistry.Register("ODataPublish$PublishedEnumerationValue", func() element.Element { + return initPublishedEnumerationValue() + }) + codec.DefaultRegistry.Register("ODataPublish$PublishedId", func() element.Element { + return initPublishedId() + }) + codec.DefaultRegistry.Register("ODataPublish$PublishedMicroflow", func() element.Element { + return initPublishedMicroflow() + }) + codec.DefaultRegistry.Register("ODataPublish$PublishedMicroflowParameter", func() element.Element { + return initPublishedMicroflowParameter() + }) + codec.DefaultRegistry.Register("ODataPublish$PublishedODataService2", func() element.Element { + return initPublishedODataService2() + }) + codec.DefaultRegistry.Register("ODataPublish$QueryOptions", func() element.Element { + return initQueryOptions() + }) + codec.DefaultRegistry.Register("ODataPublish$ReadSource", func() element.Element { + return initReadSource() + }) + codec.DefaultRegistry.Register("ODataPublish$ServiceFeed", func() element.Element { + return initServiceFeed() + }) + codec.DefaultRegistry.Register("PublishedODataServices$PublishedODataMember", func() element.Element { + return initPublishedODataMember() + }) + codec.DefaultRegistry.Register("ConsumedODataServices$ConsumedODataServiceHeader", func() element.Element { + return initConsumedODataServiceHeader() + }) +} diff --git a/modelsdk/gen/odatapublish/version.go b/modelsdk/gen/odatapublish/version.go new file mode 100644 index 00000000..265a95ad --- /dev/null +++ b/modelsdk/gen/odatapublish/version.go @@ -0,0 +1,77 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package odatapublish + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "ODataPublish$CallMicroflowToChange": { + Properties: map[string]version.PropertyVersionInfo{ + "microflow": {}, + }, + }, + "ODataPublish$EntitySet": { + Properties: map[string]version.PropertyVersionInfo{ + "alternativeExposedName": {Introduced: "10.13.0"}, + "deleteMode": {Required: true}, + "entityType": {Required: true}, + "insertMode": {Required: true}, + "queryOptions": {Required: true}, + "readMode": {Required: true}, + "updateMode": {Required: true}, + }, + }, + "ODataPublish$EntityType": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true}, + }, + }, + "ODataPublish$PublishedAssociationEnd": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true}, + }, + }, + "ODataPublish$PublishedAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "stringAsGuid": {Introduced: "10.12.0"}, + }, + }, + "ODataPublish$PublishedContract": { + Properties: map[string]version.PropertyVersionInfo{ + "graphQL": {Introduced: "10.13.0"}, + "serviceFeed": {Required: true}, + }, + }, + "ODataPublish$PublishedEnumeration": { + Properties: map[string]version.PropertyVersionInfo{ + "enumeration": {Required: true}, + }, + }, + "ODataPublish$PublishedEnumerationValue": { + Properties: map[string]version.PropertyVersionInfo{ + "enumerationValue": {Required: true}, + }, + }, + "ODataPublish$PublishedMicroflow": { + Properties: map[string]version.PropertyVersionInfo{ + "alternativeExposedName": {Introduced: "10.13.0"}, + "microflow": {Required: true}, + "returnType": {Required: true}, + }, + }, + "ODataPublish$PublishedMicroflowParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "dataType": {Required: true}, + "microflowParameter": {Required: true}, + }, + }, + "ODataPublish$PublishedODataService2": { + Properties: map[string]version.PropertyVersionInfo{ + "includeMetadataByDefault": {Introduced: "10.8.0"}, + "supportsGraphQL": {Introduced: "10.12.0"}, + }, + }, +} diff --git a/modelsdk/gen/pages/enums.go b/modelsdk/gen/pages/enums.go new file mode 100644 index 00000000..0335e33b --- /dev/null +++ b/modelsdk/gen/pages/enums.go @@ -0,0 +1,605 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package pages + +// AggregateFunction enumerates the possible values for the AggregateFunction type. +type AggregateFunction = string + +const ( + AggregateFunctionNone AggregateFunction = "None" + AggregateFunctionAverage AggregateFunction = "Average" + AggregateFunctionMaximum AggregateFunction = "Maximum" + AggregateFunctionMinimum AggregateFunction = "Minimum" + AggregateFunctionSum AggregateFunction = "Sum" + AggregateFunctionCount AggregateFunction = "Count" +) + +// AlignmentEnum enumerates the possible values for the AlignmentEnum type. +type AlignmentEnum = string + +const ( + AlignmentEnumLeft AlignmentEnum = "Left" + AlignmentEnumCenter AlignmentEnum = "Center" + AlignmentEnumRight AlignmentEnum = "Right" +) + +// AutocompletePurposeType enumerates the possible values for the AutocompletePurposeType type. +type AutocompletePurposeType = string + +const ( + AutocompletePurposeTypeOn AutocompletePurposeType = "On" + AutocompletePurposeTypeOff AutocompletePurposeType = "Off" + AutocompletePurposeTypeFullName AutocompletePurposeType = "FullName" + AutocompletePurposeTypeHonorificPrefix AutocompletePurposeType = "HonorificPrefix" + AutocompletePurposeTypeGivenName AutocompletePurposeType = "GivenName" + AutocompletePurposeTypeAdditionalName AutocompletePurposeType = "AdditionalName" + AutocompletePurposeTypeFamilyName AutocompletePurposeType = "FamilyName" + AutocompletePurposeTypeHonorificSuffix AutocompletePurposeType = "HonorificSuffix" + AutocompletePurposeTypeNickname AutocompletePurposeType = "Nickname" + AutocompletePurposeTypeJobTitle AutocompletePurposeType = "JobTitle" + AutocompletePurposeTypeUsername AutocompletePurposeType = "Username" + AutocompletePurposeTypeNewPassword AutocompletePurposeType = "NewPassword" + AutocompletePurposeTypeCurrentPassword AutocompletePurposeType = "CurrentPassword" + AutocompletePurposeTypeCompanyName AutocompletePurposeType = "CompanyName" + AutocompletePurposeTypeStreetAddress AutocompletePurposeType = "StreetAddress" + AutocompletePurposeTypeStreetAddressLine1 AutocompletePurposeType = "StreetAddressLine1" + AutocompletePurposeTypeStreetAddressLine2 AutocompletePurposeType = "StreetAddressLine2" + AutocompletePurposeTypeStreetAddressLine3 AutocompletePurposeType = "StreetAddressLine3" + AutocompletePurposeTypeAddressLevel4 AutocompletePurposeType = "AddressLevel4" + AutocompletePurposeTypeAddressLevel3 AutocompletePurposeType = "AddressLevel3" + AutocompletePurposeTypeAddressLevel2 AutocompletePurposeType = "AddressLevel2" + AutocompletePurposeTypeAddressLevel1 AutocompletePurposeType = "AddressLevel1" + AutocompletePurposeTypeCountryCode AutocompletePurposeType = "CountryCode" + AutocompletePurposeTypeCountryName AutocompletePurposeType = "CountryName" + AutocompletePurposeTypePostalCode AutocompletePurposeType = "PostalCode" + AutocompletePurposeTypeCreditCardFullName AutocompletePurposeType = "CreditCardFullName" + AutocompletePurposeTypeCreditCardGivenName AutocompletePurposeType = "CreditCardGivenName" + AutocompletePurposeTypeCreditCardAdditionalName AutocompletePurposeType = "CreditCardAdditionalName" + AutocompletePurposeTypeCreditCardFamilyName AutocompletePurposeType = "CreditCardFamilyName" + AutocompletePurposeTypeCreditCardNumber AutocompletePurposeType = "CreditCardNumber" + AutocompletePurposeTypeCreditCardExpiration AutocompletePurposeType = "CreditCardExpiration" + AutocompletePurposeTypeCreditCardExpirationMonth AutocompletePurposeType = "CreditCardExpirationMonth" + AutocompletePurposeTypeCreditCardExpirationYear AutocompletePurposeType = "CreditCardExpirationYear" + AutocompletePurposeTypeCreditCardSecurityCode AutocompletePurposeType = "CreditCardSecurityCode" + AutocompletePurposeTypeCreditCardType AutocompletePurposeType = "CreditCardType" + AutocompletePurposeTypeTransactionCurrency AutocompletePurposeType = "TransactionCurrency" + AutocompletePurposeTypeTransactionAmount AutocompletePurposeType = "TransactionAmount" + AutocompletePurposeTypeLanguage AutocompletePurposeType = "Language" + AutocompletePurposeTypeBirthday AutocompletePurposeType = "Birthday" + AutocompletePurposeTypeDayOfBirth AutocompletePurposeType = "DayOfBirth" + AutocompletePurposeTypeMonthOfBirth AutocompletePurposeType = "MonthOfBirth" + AutocompletePurposeTypeYearOfBirth AutocompletePurposeType = "YearOfBirth" + AutocompletePurposeTypeSex AutocompletePurposeType = "Sex" + AutocompletePurposeTypeUrl AutocompletePurposeType = "Url" + AutocompletePurposeTypePhoto AutocompletePurposeType = "Photo" + AutocompletePurposeTypeTelephoneNumber AutocompletePurposeType = "TelephoneNumber" + AutocompletePurposeTypeTelephoneCountryCode AutocompletePurposeType = "TelephoneCountryCode" + AutocompletePurposeTypeTelephoneWithoutCountryCode AutocompletePurposeType = "TelephoneWithoutCountryCode" + AutocompletePurposeTypeTelephoneAreaCode AutocompletePurposeType = "TelephoneAreaCode" + AutocompletePurposeTypeTelephoneLocal AutocompletePurposeType = "TelephoneLocal" + AutocompletePurposeTypeTelephoneLocalPrefix AutocompletePurposeType = "TelephoneLocalPrefix" + AutocompletePurposeTypeTelephoneLocalSuffix AutocompletePurposeType = "TelephoneLocalSuffix" + AutocompletePurposeTypeTelephoneExtension AutocompletePurposeType = "TelephoneExtension" + AutocompletePurposeTypeEmail AutocompletePurposeType = "Email" + AutocompletePurposeTypeInstantMessageProtocol AutocompletePurposeType = "InstantMessageProtocol" +) + +// Autofocus enumerates the possible values for the Autofocus type. +type Autofocus = string + +const ( + AutofocusOff Autofocus = "Off" + AutofocusDesktopOnly Autofocus = "DesktopOnly" + AutofocusAllPlatforms Autofocus = "AllPlatforms" +) + +// ButtonAriaRoleType enumerates the possible values for the ButtonAriaRoleType type. +type ButtonAriaRoleType = string + +const ( + ButtonAriaRoleTypeButton ButtonAriaRoleType = "Button" + ButtonAriaRoleTypeLink ButtonAriaRoleType = "Link" + ButtonAriaRoleTypeCheckbox ButtonAriaRoleType = "Checkbox" + ButtonAriaRoleTypeRadio ButtonAriaRoleType = "Radio" + ButtonAriaRoleTypeTab ButtonAriaRoleType = "Tab" + ButtonAriaRoleTypeMenuItem ButtonAriaRoleType = "MenuItem" + ButtonAriaRoleTypeMenuItemCheckbox ButtonAriaRoleType = "MenuItemCheckbox" + ButtonAriaRoleTypeMenuItemRadio ButtonAriaRoleType = "MenuItemRadio" + ButtonAriaRoleTypeOption ButtonAriaRoleType = "Option" + ButtonAriaRoleTypeSwitch ButtonAriaRoleType = "Switch" + ButtonAriaRoleTypeTreeItem ButtonAriaRoleType = "TreeItem" +) + +// ButtonStyle enumerates the possible values for the ButtonStyle type. +type ButtonStyle = string + +const ( + ButtonStyleDefault ButtonStyle = "Default" + ButtonStyleInverse ButtonStyle = "Inverse" + ButtonStylePrimary ButtonStyle = "Primary" + ButtonStyleInfo ButtonStyle = "Info" + ButtonStyleSuccess ButtonStyle = "Success" + ButtonStyleWarning ButtonStyle = "Warning" + ButtonStyleDanger ButtonStyle = "Danger" +) + +// ClickTypeType enumerates the possible values for the ClickTypeType type. +type ClickTypeType = string + +const ( + ClickTypeTypeSingle ClickTypeType = "Single" + ClickTypeTypeDouble ClickTypeType = "Double" +) + +// ContainerRenderMode enumerates the possible values for the ContainerRenderMode type. +type ContainerRenderMode = string + +const ( + ContainerRenderModeDiv ContainerRenderMode = "Div" + ContainerRenderModeSection ContainerRenderMode = "Section" + ContainerRenderModeArticle ContainerRenderMode = "Article" + ContainerRenderModeHeader ContainerRenderMode = "Header" + ContainerRenderModeFooter ContainerRenderMode = "Footer" + ContainerRenderModeMain ContainerRenderMode = "Main" + ContainerRenderModeNav ContainerRenderMode = "Nav" + ContainerRenderModeAside ContainerRenderMode = "Aside" + ContainerRenderModeHgroup ContainerRenderMode = "Hgroup" + ContainerRenderModeAddress ContainerRenderMode = "Address" +) + +// ContainerWidth enumerates the possible values for the ContainerWidth type. +type ContainerWidth = string + +const ( + ContainerWidthFullWidth ContainerWidth = "FullWidth" + ContainerWidthFixedWidth ContainerWidth = "FixedWidth" +) + +// DataViewReadOnlyStyle enumerates the possible values for the DataViewReadOnlyStyle type. +type DataViewReadOnlyStyle = string + +const ( + DataViewReadOnlyStyleControl DataViewReadOnlyStyle = "Control" + DataViewReadOnlyStyleText DataViewReadOnlyStyle = "Text" +) + +// DatabaseConstraintOperator enumerates the possible values for the DatabaseConstraintOperator type. +type DatabaseConstraintOperator = string + +const ( + DatabaseConstraintOperatorEquals DatabaseConstraintOperator = "Equals" + DatabaseConstraintOperatorNotEquals DatabaseConstraintOperator = "NotEquals" + DatabaseConstraintOperatorContains DatabaseConstraintOperator = "Contains" + DatabaseConstraintOperatorNotContains DatabaseConstraintOperator = "NotContains" + DatabaseConstraintOperatorLessThan DatabaseConstraintOperator = "LessThan" + DatabaseConstraintOperatorLessThanOrEquals DatabaseConstraintOperator = "LessThanOrEquals" + DatabaseConstraintOperatorGreaterThan DatabaseConstraintOperator = "GreaterThan" + DatabaseConstraintOperatorGreaterThanOrEquals DatabaseConstraintOperator = "GreaterThanOrEquals" +) + +// DateFormat enumerates the possible values for the DateFormat type. +type DateFormat = string + +const ( + DateFormatDate DateFormat = "Date" + DateFormatTime DateFormat = "Time" + DateFormatDateTime DateFormat = "DateTime" + DateFormatCustom DateFormat = "Custom" +) + +// DesignPropertyValueType enumerates the possible values for the DesignPropertyValueType type. +type DesignPropertyValueType = string + +const ( + DesignPropertyValueTypeDropDown DesignPropertyValueType = "DropDown" + DesignPropertyValueTypeToggle DesignPropertyValueType = "Toggle" + DesignPropertyValueTypeSpacing DesignPropertyValueType = "Spacing" + DesignPropertyValueTypeColorPicker DesignPropertyValueType = "ColorPicker" + DesignPropertyValueTypeToggleButtonGroup DesignPropertyValueType = "ToggleButtonGroup" +) + +// EditableEnum enumerates the possible values for the EditableEnum type. +type EditableEnum = string + +const ( + EditableEnumAlways EditableEnum = "Always" + EditableEnumNever EditableEnum = "Never" + EditableEnumConditional EditableEnum = "Conditional" +) + +// EnumFormat enumerates the possible values for the EnumFormat type. +type EnumFormat = string + +const ( + EnumFormatText EnumFormat = "Text" + EnumFormatImage EnumFormat = "Image" +) + +// FileManagerType enumerates the possible values for the FileManagerType type. +type FileManagerType = string + +const ( + FileManagerTypeUpload FileManagerType = "Upload" + FileManagerTypeDownload FileManagerType = "Download" + FileManagerTypeBoth FileManagerType = "Both" +) + +// FormLocation enumerates the possible values for the FormLocation type. +type FormLocation = string + +const ( + FormLocationContent FormLocation = "Content" + FormLocationPopup FormLocation = "Popup" + FormLocationModalPopup FormLocation = "ModalPopup" +) + +// FormValidations enumerates the possible values for the FormValidations type. +type FormValidations = string + +const ( + FormValidationsNone FormValidations = "None" + FormValidationsWidget FormValidations = "Widget" + FormValidationsAll FormValidations = "All" +) + +// GridSelectionMode enumerates the possible values for the GridSelectionMode type. +type GridSelectionMode = string + +const ( + GridSelectionModeNone GridSelectionMode = "None" + GridSelectionModeSingle GridSelectionMode = "Single" + GridSelectionModeSingleAndMaintain GridSelectionMode = "SingleAndMaintain" + GridSelectionModeMulti GridSelectionMode = "Multi" + GridSelectionModeSimpleMulti GridSelectionMode = "SimpleMulti" +) + +// GroupBoxCollapsible enumerates the possible values for the GroupBoxCollapsible type. +type GroupBoxCollapsible = string + +const ( + GroupBoxCollapsibleNo GroupBoxCollapsible = "No" + GroupBoxCollapsibleYesInitiallyExpanded GroupBoxCollapsible = "YesInitiallyExpanded" + GroupBoxCollapsibleYesInitiallyCollapsed GroupBoxCollapsible = "YesInitiallyCollapsed" +) + +// GroupBoxRenderMode enumerates the possible values for the GroupBoxRenderMode type. +type GroupBoxRenderMode = string + +const ( + GroupBoxRenderModeDiv GroupBoxRenderMode = "Div" + GroupBoxRenderModeH1 GroupBoxRenderMode = "H1" + GroupBoxRenderModeH2 GroupBoxRenderMode = "H2" + GroupBoxRenderModeH3 GroupBoxRenderMode = "H3" + GroupBoxRenderModeH4 GroupBoxRenderMode = "H4" + GroupBoxRenderModeH5 GroupBoxRenderMode = "H5" + GroupBoxRenderModeH6 GroupBoxRenderMode = "H6" +) + +// ImageSizeUnit enumerates the possible values for the ImageSizeUnit type. +type ImageSizeUnit = string + +const ( + ImageSizeUnitAuto ImageSizeUnit = "Auto" + ImageSizeUnitPixels ImageSizeUnit = "Pixels" + ImageSizeUnitPercentage ImageSizeUnit = "Percentage" +) + +// KeyboardType enumerates the possible values for the KeyboardType type. +type KeyboardType = string + +const ( + KeyboardTypeNumberPad KeyboardType = "NumberPad" + KeyboardTypeDecimalPad KeyboardType = "DecimalPad" + KeyboardTypeEmailAddress KeyboardType = "EmailAddress" + KeyboardTypePhonePad KeyboardType = "PhonePad" + KeyboardTypeURL KeyboardType = "URL" + KeyboardTypeDefault KeyboardType = "Default" +) + +// LabelPosition enumerates the possible values for the LabelPosition type. +type LabelPosition = string + +const ( + LabelPositionDefault LabelPosition = "Default" + LabelPositionBeforeControl LabelPosition = "BeforeControl" + LabelPositionAfterControl LabelPosition = "AfterControl" +) + +// LayoutGridAlignment enumerates the possible values for the LayoutGridAlignment type. +type LayoutGridAlignment = string + +const ( + LayoutGridAlignmentNone LayoutGridAlignment = "None" + LayoutGridAlignmentStart LayoutGridAlignment = "Start" + LayoutGridAlignmentCenter LayoutGridAlignment = "Center" + LayoutGridAlignmentEnd LayoutGridAlignment = "End" +) + +// LayoutModeType enumerates the possible values for the LayoutModeType type. +type LayoutModeType = string + +const ( + LayoutModeTypeHeadline LayoutModeType = "Headline" + LayoutModeTypeSidebar LayoutModeType = "Sidebar" +) + +// LayoutType enumerates the possible values for the LayoutType type. +type LayoutType = string + +const ( + LayoutTypeResponsive LayoutType = "Responsive" + LayoutTypeTablet LayoutType = "Tablet" + LayoutTypePhone LayoutType = "Phone" + LayoutTypeModalPopup LayoutType = "ModalPopup" + LayoutTypePopup LayoutType = "Popup" + LayoutTypeLegacy LayoutType = "Legacy" +) + +// LinkType enumerates the possible values for the LinkType type. +type LinkType = string + +const ( + LinkTypeWeb LinkType = "Web" + LinkTypeEmail LinkType = "Email" + LinkTypeCall LinkType = "Call" + LinkTypeText LinkType = "Text" +) + +// MobileFooterType enumerates the possible values for the MobileFooterType type. +type MobileFooterType = string + +const ( + MobileFooterTypeNone MobileFooterType = "None" + MobileFooterTypeMenuBar MobileFooterType = "MenuBar" + MobileFooterTypeCustom MobileFooterType = "Custom" +) + +// NativeLayoutType enumerates the possible values for the NativeLayoutType type. +type NativeLayoutType = string + +const ( + NativeLayoutTypeDefault NativeLayoutType = "Default" + NativeLayoutTypeTopLevel NativeLayoutType = "TopLevel" + NativeLayoutTypePopup NativeLayoutType = "Popup" +) + +// NativeRenderMode enumerates the possible values for the NativeRenderMode type. +type NativeRenderMode = string + +const ( + NativeRenderModeCheckBox NativeRenderMode = "CheckBox" + NativeRenderModeSwitch NativeRenderMode = "Switch" +) + +// NativeTextStyle enumerates the possible values for the NativeTextStyle type. +type NativeTextStyle = string + +const ( + NativeTextStyleText NativeTextStyle = "Text" + NativeTextStyleHeading1 NativeTextStyle = "Heading1" + NativeTextStyleHeading2 NativeTextStyle = "Heading2" + NativeTextStyleHeading3 NativeTextStyle = "Heading3" + NativeTextStyleHeading4 NativeTextStyle = "Heading4" + NativeTextStyleHeading5 NativeTextStyle = "Heading5" + NativeTextStyleHeading6 NativeTextStyle = "Heading6" +) + +// NewButtonEditLocation enumerates the possible values for the NewButtonEditLocation type. +type NewButtonEditLocation = string + +const ( + NewButtonEditLocationInlineAtTop NewButtonEditLocation = "InlineAtTop" + NewButtonEditLocationInlineAtBottom NewButtonEditLocation = "InlineAtBottom" + NewButtonEditLocationForm NewButtonEditLocation = "Form" +) + +// PageTemplateType enumerates the possible values for the PageTemplateType type. +type PageTemplateType = string + +const ( + PageTemplateTypeStandard PageTemplateType = "Standard" + PageTemplateTypeEdit PageTemplateType = "Edit" + PageTemplateTypeSelect PageTemplateType = "Select" +) + +// ProgressBarType enumerates the possible values for the ProgressBarType type. +type ProgressBarType = string + +const ( + ProgressBarTypeNone ProgressBarType = "None" + ProgressBarTypeNonBlocking ProgressBarType = "NonBlocking" + ProgressBarTypeBlocking ProgressBarType = "Blocking" +) + +// ReadOnlyStyle enumerates the possible values for the ReadOnlyStyle type. +type ReadOnlyStyle = string + +const ( + ReadOnlyStyleInherit ReadOnlyStyle = "Inherit" + ReadOnlyStyleControl ReadOnlyStyle = "Control" + ReadOnlyStyleText ReadOnlyStyle = "Text" +) + +// ReferenceSelectorRenderModeType enumerates the possible values for the ReferenceSelectorRenderModeType type. +type ReferenceSelectorRenderModeType = string + +const ( + ReferenceSelectorRenderModeTypeForm ReferenceSelectorRenderModeType = "Form" + ReferenceSelectorRenderModeTypeDropDown ReferenceSelectorRenderModeType = "DropDown" +) + +// RenderType enumerates the possible values for the RenderType type. +type RenderType = string + +const ( + RenderTypeButton RenderType = "Button" + RenderTypeLink RenderType = "Link" +) + +// ScrollBehavior enumerates the possible values for the ScrollBehavior type. +type ScrollBehavior = string + +const ( + ScrollBehaviorPerRegion ScrollBehavior = "PerRegion" + ScrollBehaviorFullWidget ScrollBehavior = "FullWidget" +) + +// ScrollDirection enumerates the possible values for the ScrollDirection type. +type ScrollDirection = string + +const ( + ScrollDirectionVertical ScrollDirection = "Vertical" + ScrollDirectionHorizontal ScrollDirection = "Horizontal" +) + +// SearchBarTypeEnum enumerates the possible values for the SearchBarTypeEnum type. +type SearchBarTypeEnum = string + +const ( + SearchBarTypeEnumNone SearchBarTypeEnum = "None" + SearchBarTypeEnumFoldableOpen SearchBarTypeEnum = "FoldableOpen" + SearchBarTypeEnumFoldableClosed SearchBarTypeEnum = "FoldableClosed" + SearchBarTypeEnumAlwaysOpen SearchBarTypeEnum = "AlwaysOpen" +) + +// SearchFieldOperator enumerates the possible values for the SearchFieldOperator type. +type SearchFieldOperator = string + +const ( + SearchFieldOperatorContains SearchFieldOperator = "Contains" + SearchFieldOperatorStartsWith SearchFieldOperator = "StartsWith" + SearchFieldOperatorGreater SearchFieldOperator = "Greater" + SearchFieldOperatorGreaterOrEqual SearchFieldOperator = "GreaterOrEqual" + SearchFieldOperatorEqual SearchFieldOperator = "Equal" + SearchFieldOperatorNotEqual SearchFieldOperator = "NotEqual" + SearchFieldOperatorSmallerOrEqual SearchFieldOperator = "SmallerOrEqual" + SearchFieldOperatorSmaller SearchFieldOperator = "Smaller" +) + +// SearchFieldType enumerates the possible values for the SearchFieldType type. +type SearchFieldType = string + +const ( + SearchFieldTypeNormal SearchFieldType = "Normal" + SearchFieldTypeHidden SearchFieldType = "Hidden" + SearchFieldTypeReadOnly SearchFieldType = "ReadOnly" +) + +// SelectionType enumerates the possible values for the SelectionType type. +type SelectionType = string + +const ( + SelectionTypeSelectPage SelectionType = "SelectPage" + SelectionTypeSelectAll SelectionType = "SelectAll" +) + +// ShowPagingBarType enumerates the possible values for the ShowPagingBarType type. +type ShowPagingBarType = string + +const ( + ShowPagingBarTypeYesWithTotalCount ShowPagingBarType = "YesWithTotalCount" + ShowPagingBarTypeYesWithoutTotalCount ShowPagingBarType = "YesWithoutTotalCount" + ShowPagingBarTypeNo ShowPagingBarType = "No" +) + +// SidebarToggleMode enumerates the possible values for the SidebarToggleMode type. +type SidebarToggleMode = string + +const ( + SidebarToggleModePushContentAside SidebarToggleMode = "PushContentAside" + SidebarToggleModeSlideOverContent SidebarToggleMode = "SlideOverContent" + SidebarToggleModeShrinkContent SidebarToggleMode = "ShrinkContent" +) + +// SidebarToggleRegion enumerates the possible values for the SidebarToggleRegion type. +type SidebarToggleRegion = string + +const ( + SidebarToggleRegionLeft SidebarToggleRegion = "Left" + SidebarToggleRegionRight SidebarToggleRegion = "Right" +) + +// SimpleMenuBarOrientation enumerates the possible values for the SimpleMenuBarOrientation type. +type SimpleMenuBarOrientation = string + +const ( + SimpleMenuBarOrientationHorizontal SimpleMenuBarOrientation = "Horizontal" + SimpleMenuBarOrientationVertical SimpleMenuBarOrientation = "Vertical" +) + +// SizeMode enumerates the possible values for the SizeMode type. +type SizeMode = string + +const ( + SizeModeAuto SizeMode = "Auto" + SizeModePixels SizeMode = "Pixels" + SizeModePercentage SizeMode = "Percentage" +) + +// SnippetType enumerates the possible values for the SnippetType type. +type SnippetType = string + +const ( + SnippetTypeWeb SnippetType = "Web" + SnippetTypeNative SnippetType = "Native" +) + +// SortDirection enumerates the possible values for the SortDirection type. +type SortDirection = string + +const ( + SortDirectionAscending SortDirection = "Ascending" + SortDirectionDescending SortDirection = "Descending" +) + +// SubmitBehaviourType enumerates the possible values for the SubmitBehaviourType type. +type SubmitBehaviourType = string + +const ( + SubmitBehaviourTypeOnEndEditing SubmitBehaviourType = "OnEndEditing" + SubmitBehaviourTypeWhileEditing SubmitBehaviourType = "WhileEditing" +) + +// TableCellRenderModeType enumerates the possible values for the TableCellRenderModeType type. +type TableCellRenderModeType = string + +const ( + TableCellRenderModeTypeDefault TableCellRenderModeType = "Default" + TableCellRenderModeTypeHeader TableCellRenderModeType = "Header" + TableCellRenderModeTypeTitle TableCellRenderModeType = "Title" +) + +// TextRenderMode enumerates the possible values for the TextRenderMode type. +type TextRenderMode = string + +const ( + TextRenderModeText TextRenderMode = "Text" + TextRenderModeParagraph TextRenderMode = "Paragraph" + TextRenderModeH1 TextRenderMode = "H1" + TextRenderModeH2 TextRenderMode = "H2" + TextRenderModeH3 TextRenderMode = "H3" + TextRenderModeH4 TextRenderMode = "H4" + TextRenderModeH5 TextRenderMode = "H5" + TextRenderModeH6 TextRenderMode = "H6" +) + +// ToggleMode enumerates the possible values for the ToggleMode type. +type ToggleMode = string + +const ( + ToggleModeNone ToggleMode = "None" + ToggleModePushContentAside ToggleMode = "PushContentAside" + ToggleModeSlideOverContent ToggleMode = "SlideOverContent" + ToggleModeShrinkContentInitiallyOpen ToggleMode = "ShrinkContentInitiallyOpen" + ToggleModeShrinkContentInitiallyClosed ToggleMode = "ShrinkContentInitiallyClosed" +) + +// UnitEnum enumerates the possible values for the UnitEnum type. +type UnitEnum = string + +const ( + UnitEnumWeight UnitEnum = "Weight" + UnitEnumPixels UnitEnum = "Pixels" +) diff --git a/modelsdk/gen/pages/refs.go b/modelsdk/gen/pages/refs.go new file mode 100644 index 00000000..e51fa288 --- /dev/null +++ b/modelsdk/gen/pages/refs.go @@ -0,0 +1,184 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package pages + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Forms$CallNanoflowClientAction", []codec.RefMeta{ + {Prop: "Nanoflow", Kind: codec.RefByName, Target: "Microflows$Nanoflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$CallWorkflowClientAction", []codec.RefMeta{ + {Prop: "Workflow", Kind: codec.RefByName, Target: "Workflows$Workflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$ColumnGrid", []codec.RefMeta{ + {Prop: "TooltipPage", Kind: codec.RefByName, Target: "Forms$Page"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$ConditionalSettings", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$ConditionalEditabilitySettings", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$ConditionalVisibilitySettings", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + {Prop: "ModuleRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$DataGrid", []codec.RefMeta{ + {Prop: "TooltipPage", Kind: codec.RefByName, Target: "Forms$Page"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$DataViewControlBar", []codec.RefMeta{ + {Prop: "CloseButton", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$DataViewSource", []codec.RefMeta{ + {Prop: "PageParameter", Kind: codec.RefByName, Target: "Forms$PageParameter"}, + {Prop: "SnippetParameter", Kind: codec.RefByName, Target: "Forms$SnippetParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$DatabaseConstraint", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$DropDownButtonItem", []codec.RefMeta{ + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$DynamicImageViewer", []codec.RefMeta{ + {Prop: "DefaultImage", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$ImageViewer", []codec.RefMeta{ + {Prop: "DefaultImage", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$GridControlBar", []codec.RefMeta{ + {Prop: "DefaultButtonPointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$GridNewButton", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$GridXPathSource", []codec.RefMeta{ + {Prop: "RemoveFromContextIds", Kind: codec.RefByNameList, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$IconCollectionIcon", []codec.RefMeta{ + {Prop: "Image", Kind: codec.RefByName, Target: "CustomIcons$CustomIcon"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$ImageIcon", []codec.RefMeta{ + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$Layout", []codec.RefMeta{ + {Prop: "MainPlaceholder", Kind: codec.RefByName, Target: "Forms$LayoutParameter"}, + {Prop: "AcceptButtonPlaceholder", Kind: codec.RefByName, Target: "Forms$LayoutParameter"}, + {Prop: "CancelButtonPlaceholder", Kind: codec.RefByName, Target: "Forms$LayoutParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$LayoutCall", []codec.RefMeta{ + {Prop: "Layout", Kind: codec.RefByName, Target: "Forms$Layout"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$LayoutCallArgument", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Forms$LayoutParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$ListViewTemplate", []codec.RefMeta{ + {Prop: "Specialization", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$MenuDocumentSource", []codec.RefMeta{ + {Prop: "Menu", Kind: codec.RefByName, Target: "Menus$MenuDocument"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$MicroflowParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + {Prop: "Widget", Kind: codec.RefByName, Target: "Forms$EntityWidget"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$MicroflowSettings", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$NanoflowParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Microflows$NanoflowParameter"}, + {Prop: "Widget", Kind: codec.RefByName, Target: "Forms$EntityWidget"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$NanoflowSource", []codec.RefMeta{ + {Prop: "Nanoflow", Kind: codec.RefByName, Target: "Microflows$Nanoflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$NavigationSource", []codec.RefMeta{ + {Prop: "NavigationProfile", Kind: codec.RefByName, Target: "Navigation$NavigationProfile"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$NewButton", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$OfflineSchema", []codec.RefMeta{ + {Prop: "Role", Kind: codec.RefByName, Target: "Security$UserRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$OpenWorkflowClientAction", []codec.RefMeta{ + {Prop: "DefaultPage", Kind: codec.RefByName, Target: "Forms$Page"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$Page", []codec.RefMeta{ + {Prop: "AllowedRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$PageForSpecialization", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$FormForSpecialization", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$PageParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Forms$PageParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$FormCallArgument", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Forms$PageParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$PagePrimitiveParameterUrlSegment", []codec.RefMeta{ + {Prop: "PageParameter", Kind: codec.RefByName, Target: "Forms$PageParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$PageSettings", []codec.RefMeta{ + {Prop: "Form", Kind: codec.RefByName, Target: "Forms$Page"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$FormSettings", []codec.RefMeta{ + {Prop: "Form", Kind: codec.RefByName, Target: "Forms$Page"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$PageVariable", []codec.RefMeta{ + {Prop: "Widget", Kind: codec.RefByName, Target: "Forms$Widget"}, + {Prop: "PageParameter", Kind: codec.RefByName, Target: "Forms$PageParameter"}, + {Prop: "SnippetParameter", Kind: codec.RefByName, Target: "Forms$SnippetParameter"}, + {Prop: "LocalVariable", Kind: codec.RefByName, Target: "Forms$LocalVariable"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$ParameterAttributeUrlSegment", []codec.RefMeta{ + {Prop: "PageParameter", Kind: codec.RefByName, Target: "Forms$PageParameter"}, + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$ParameterIdUrlSegment", []codec.RefMeta{ + {Prop: "PageParameter", Kind: codec.RefByName, Target: "Forms$PageParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$ReferenceSetSelector", []codec.RefMeta{ + {Prop: "TooltipPage", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "RemoveFromContextEntities", Kind: codec.RefByNameList, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$RetrievalQuery", []codec.RefMeta{ + {Prop: "AllowedUserRoles", Kind: codec.RefByNameList, Target: "Security$UserRole"}, + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$RuntimeOperation", []codec.RefMeta{ + {Prop: "AllowedUserRoles", Kind: codec.RefByNameList, Target: "Security$UserRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$SelectorXPathSource", []codec.RefMeta{ + {Prop: "RemoveFromContextEntities", Kind: codec.RefByNameList, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$SetTaskOutcomeClientAction", []codec.RefMeta{ + {Prop: "Outcome", Kind: codec.RefByName, Target: "Workflows$UserTaskOutcome"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$Snippet", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$SnippetCall", []codec.RefMeta{ + {Prop: "Snippet", Kind: codec.RefByName, Target: "Forms$Snippet"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$SnippetParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Forms$SnippetParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$StaticImageViewer", []codec.RefMeta{ + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$TabContainer", []codec.RefMeta{ + {Prop: "DefaultPage", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$TabControl", []codec.RefMeta{ + {Prop: "DefaultPage", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Forms$UserRoleSet", []codec.RefMeta{ + {Prop: "UserRoles", Kind: codec.RefByNameList, Target: "Security$UserRole"}, + }) +} diff --git a/modelsdk/gen/pages/types.go b/modelsdk/gen/pages/types.go new file mode 100644 index 00000000..1c5d732e --- /dev/null +++ b/modelsdk/gen/pages/types.go @@ -0,0 +1,34040 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package pages + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// AbstractDesignPropertyValue +// ──────────────────────────────────────────────────────── + +type AbstractDesignPropertyValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AbstractDesignPropertyValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// AccessibilitySettings +// ──────────────────────────────────────────────────────── + +type AccessibilitySettings struct { + element.Base + screenReaderDescription *property.Part[element.Element] + screenReaderTitle *property.Part[element.Element] + accessible *property.Primitive[bool] +} + +// ScreenReaderDescription returns the value of the screenReaderDescription property. +func (o *AccessibilitySettings) ScreenReaderDescription() element.Element { + return o.screenReaderDescription.Get() +} + +// SetScreenReaderDescription sets the value of the screenReaderDescription property. +func (o *AccessibilitySettings) SetScreenReaderDescription(v element.Element) { + o.screenReaderDescription.Set(v) +} + +// ScreenReaderTitle returns the value of the screenReaderTitle property. +func (o *AccessibilitySettings) ScreenReaderTitle() element.Element { + return o.screenReaderTitle.Get() +} + +// SetScreenReaderTitle sets the value of the screenReaderTitle property. +func (o *AccessibilitySettings) SetScreenReaderTitle(v element.Element) { + o.screenReaderTitle.Set(v) +} + +// Accessible returns the value of the accessible property. +func (o *AccessibilitySettings) Accessible() bool { + return o.accessible.Get() +} + +// SetAccessible sets the value of the accessible property. +func (o *AccessibilitySettings) SetAccessible(v bool) { + o.accessible.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AccessibilitySettings) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "ScreenReaderDescription"); err == nil { + o.screenReaderDescription.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderTitle"); err == nil { + o.screenReaderTitle.SetFromDecode(child) + } + o.accessible.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Widget +// ──────────────────────────────────────────────────────── + +type Widget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *Widget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Widget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *Widget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Widget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Widget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Widget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *Widget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *Widget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *Widget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *Widget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Widget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConditionallyVisibleWidget +// ──────────────────────────────────────────────────────── + +type ConditionallyVisibleWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *ConditionallyVisibleWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConditionallyVisibleWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ConditionallyVisibleWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ConditionallyVisibleWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ConditionallyVisibleWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ConditionallyVisibleWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ConditionallyVisibleWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ConditionallyVisibleWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ConditionallyVisibleWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ConditionallyVisibleWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *ConditionallyVisibleWidget) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *ConditionallyVisibleWidget) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *ConditionallyVisibleWidget) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *ConditionallyVisibleWidget) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConditionallyVisibleWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Button +// ──────────────────────────────────────────────────────── + +type Button struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *Button) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Button) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *Button) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Button) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Button) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Button) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *Button) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *Button) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *Button) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *Button) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *Button) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *Button) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *Button) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *Button) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *Button) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *Button) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *Button) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *Button) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *Button) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *Button) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *Button) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *Button) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *Button) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *Button) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Button) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ActionButton +// ──────────────────────────────────────────────────────── + +type ActionButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] + action *property.Part[element.Element] + ariaRole *property.Enum[string] + disabledDuringAction *property.Primitive[bool] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *ActionButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ActionButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ActionButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ActionButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ActionButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ActionButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ActionButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ActionButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ActionButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ActionButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *ActionButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *ActionButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *ActionButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *ActionButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ActionButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ActionButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *ActionButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *ActionButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *ActionButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *ActionButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *ActionButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *ActionButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *ActionButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *ActionButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// Action returns the value of the action property. +func (o *ActionButton) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *ActionButton) SetAction(v element.Element) { + o.action.Set(v) +} + +// AriaRole returns the value of the ariaRole property. +func (o *ActionButton) AriaRole() string { + return o.ariaRole.Get() +} + +// SetAriaRole sets the value of the ariaRole property. +func (o *ActionButton) SetAriaRole(v string) { + o.ariaRole.Set(v) +} + +// DisabledDuringAction returns the value of the disabledDuringAction property. +func (o *ActionButton) DisabledDuringAction() bool { + return o.disabledDuringAction.Get() +} + +// SetDisabledDuringAction sets the value of the disabledDuringAction property. +func (o *ActionButton) SetDisabledDuringAction(v bool) { + o.disabledDuringAction.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *ActionButton) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *ActionButton) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ActionButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } + if val, err := raw.LookupErr("AriaRole"); err == nil { + if s, ok := val.StringValueOK(); ok { o.ariaRole.SetFromDecode(s) } + } + o.disabledDuringAction.Init(raw) + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ActionItem +// ──────────────────────────────────────────────────────── + +type ActionItem struct { + element.Base + action *property.Part[element.Element] +} + +// Action returns the value of the action property. +func (o *ActionItem) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *ActionItem) SetAction(v element.Element) { + o.action.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ActionItem) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Appearance +// ──────────────────────────────────────────────────────── + +type Appearance struct { + element.Base + class *property.Primitive[string] + style *property.Primitive[string] + designProperties *property.PartList[element.Element] + dynamicClasses *property.Primitive[string] +} + +// Class returns the value of the class property. +func (o *Appearance) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Appearance) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Appearance) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Appearance) SetStyle(v string) { + o.style.Set(v) +} + +// DesignPropertiesItems returns the value of the designProperties property. +func (o *Appearance) DesignPropertiesItems() []element.Element { + return o.designProperties.Items() +} + +// AddDesignProperties appends a child element to the designProperties list. +func (o *Appearance) AddDesignProperties(v element.Element) { + o.designProperties.Append(v) +} + +// RemoveDesignProperties removes the element at the given index from the designProperties list. +func (o *Appearance) RemoveDesignProperties(index int) { + o.designProperties.Remove(index) +} + +// DynamicClasses returns the value of the dynamicClasses property. +func (o *Appearance) DynamicClasses() string { + return o.dynamicClasses.Get() +} + +// SetDynamicClasses sets the value of the dynamicClasses property. +func (o *Appearance) SetDynamicClasses(v string) { + o.dynamicClasses.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Appearance) InitFromRaw(raw bson.Raw) { + o.class.Init(raw) + o.style.Init(raw) + if children, err := codec.DecodeChildren(raw, "DesignProperties"); err == nil { + for _, child := range children { + o.designProperties.AppendFromDecode(child) + } + } + o.dynamicClasses.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataSource +// ──────────────────────────────────────────────────────── + +type DataSource struct { + element.Base + forceFullObjects *property.Primitive[bool] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *DataSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *DataSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EntityPathSource +// ──────────────────────────────────────────────────────── + +type EntityPathSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *EntityPathSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *EntityPathSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *EntityPathSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *EntityPathSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *EntityPathSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *EntityPathSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *EntityPathSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *EntityPathSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityPathSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// AssociationSource +// ──────────────────────────────────────────────────────── + +type AssociationSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *AssociationSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *AssociationSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *AssociationSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *AssociationSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *AssociationSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *AssociationSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *AssociationSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *AssociationSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AssociationSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ConditionallyEditableWidget +// ──────────────────────────────────────────────────────── + +type ConditionallyEditableWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *ConditionallyEditableWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConditionallyEditableWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ConditionallyEditableWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ConditionallyEditableWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ConditionallyEditableWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ConditionallyEditableWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ConditionallyEditableWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ConditionallyEditableWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ConditionallyEditableWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ConditionallyEditableWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *ConditionallyEditableWidget) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *ConditionallyEditableWidget) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *ConditionallyEditableWidget) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *ConditionallyEditableWidget) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *ConditionallyEditableWidget) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *ConditionallyEditableWidget) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *ConditionallyEditableWidget) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *ConditionallyEditableWidget) SetEditable(v string) { + o.editable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConditionallyEditableWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// InputWidget +// ──────────────────────────────────────────────────────── + +type InputWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *InputWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *InputWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *InputWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *InputWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *InputWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *InputWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *InputWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *InputWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *InputWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *InputWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *InputWidget) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *InputWidget) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *InputWidget) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *InputWidget) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *InputWidget) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *InputWidget) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *InputWidget) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *InputWidget) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *InputWidget) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *InputWidget) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *InputWidget) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *InputWidget) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *InputWidget) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *InputWidget) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *InputWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MemberWidget +// ──────────────────────────────────────────────────────── + +type MemberWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *MemberWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MemberWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *MemberWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *MemberWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *MemberWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *MemberWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *MemberWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *MemberWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *MemberWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *MemberWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *MemberWidget) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *MemberWidget) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *MemberWidget) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *MemberWidget) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *MemberWidget) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *MemberWidget) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *MemberWidget) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *MemberWidget) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *MemberWidget) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *MemberWidget) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *MemberWidget) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *MemberWidget) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *MemberWidget) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *MemberWidget) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *MemberWidget) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *MemberWidget) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *MemberWidget) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *MemberWidget) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *MemberWidget) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *MemberWidget) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MemberWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// AssociationWidget +// ──────────────────────────────────────────────────────── + +type AssociationWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + selectorSource *property.Part[element.Element] + selectPageSettings *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *AssociationWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *AssociationWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *AssociationWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *AssociationWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *AssociationWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *AssociationWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *AssociationWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *AssociationWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *AssociationWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *AssociationWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *AssociationWidget) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *AssociationWidget) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *AssociationWidget) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *AssociationWidget) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *AssociationWidget) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *AssociationWidget) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *AssociationWidget) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *AssociationWidget) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *AssociationWidget) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *AssociationWidget) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *AssociationWidget) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *AssociationWidget) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *AssociationWidget) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *AssociationWidget) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *AssociationWidget) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *AssociationWidget) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *AssociationWidget) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *AssociationWidget) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *AssociationWidget) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *AssociationWidget) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// SelectorSource returns the value of the selectorSource property. +func (o *AssociationWidget) SelectorSource() element.Element { + return o.selectorSource.Get() +} + +// SetSelectorSource sets the value of the selectorSource property. +func (o *AssociationWidget) SetSelectorSource(v element.Element) { + o.selectorSource.Set(v) +} + +// SelectPageSettings returns the value of the selectPageSettings property. +func (o *AssociationWidget) SelectPageSettings() element.Element { + return o.selectPageSettings.Get() +} + +// SetSelectPageSettings sets the value of the selectPageSettings property. +func (o *AssociationWidget) SetSelectPageSettings(v element.Element) { + o.selectPageSettings.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *AssociationWidget) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *AssociationWidget) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *AssociationWidget) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *AssociationWidget) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *AssociationWidget) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *AssociationWidget) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AssociationWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "SelectorSource"); err == nil { + o.selectorSource.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SelectPageSettings"); err == nil { + o.selectPageSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// AttributeWidget +// ──────────────────────────────────────────────────────── + +type AttributeWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + required *property.Primitive[bool] + requiredMessage *property.Part[element.Element] + validation *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onEnterMicroflowSettings *property.Part[element.Element] + onLeaveMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + onEnterAction *property.Part[element.Element] + onLeaveAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + ariaRequired *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *AttributeWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *AttributeWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *AttributeWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *AttributeWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *AttributeWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *AttributeWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *AttributeWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *AttributeWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *AttributeWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *AttributeWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *AttributeWidget) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *AttributeWidget) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *AttributeWidget) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *AttributeWidget) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *AttributeWidget) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *AttributeWidget) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *AttributeWidget) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *AttributeWidget) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *AttributeWidget) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *AttributeWidget) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *AttributeWidget) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *AttributeWidget) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *AttributeWidget) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *AttributeWidget) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *AttributeWidget) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *AttributeWidget) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *AttributeWidget) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *AttributeWidget) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *AttributeWidget) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *AttributeWidget) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// Required returns the value of the required property. +func (o *AttributeWidget) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *AttributeWidget) SetRequired(v bool) { + o.required.Set(v) +} + +// RequiredMessage returns the value of the requiredMessage property. +func (o *AttributeWidget) RequiredMessage() element.Element { + return o.requiredMessage.Get() +} + +// SetRequiredMessage sets the value of the requiredMessage property. +func (o *AttributeWidget) SetRequiredMessage(v element.Element) { + o.requiredMessage.Set(v) +} + +// Validation returns the value of the validation property. +func (o *AttributeWidget) Validation() element.Element { + return o.validation.Get() +} + +// SetValidation sets the value of the validation property. +func (o *AttributeWidget) SetValidation(v element.Element) { + o.validation.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *AttributeWidget) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *AttributeWidget) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnEnterMicroflowSettings returns the value of the onEnterMicroflowSettings property. +func (o *AttributeWidget) OnEnterMicroflowSettings() element.Element { + return o.onEnterMicroflowSettings.Get() +} + +// SetOnEnterMicroflowSettings sets the value of the onEnterMicroflowSettings property. +func (o *AttributeWidget) SetOnEnterMicroflowSettings(v element.Element) { + o.onEnterMicroflowSettings.Set(v) +} + +// OnLeaveMicroflowSettings returns the value of the onLeaveMicroflowSettings property. +func (o *AttributeWidget) OnLeaveMicroflowSettings() element.Element { + return o.onLeaveMicroflowSettings.Get() +} + +// SetOnLeaveMicroflowSettings sets the value of the onLeaveMicroflowSettings property. +func (o *AttributeWidget) SetOnLeaveMicroflowSettings(v element.Element) { + o.onLeaveMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *AttributeWidget) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *AttributeWidget) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// OnEnterAction returns the value of the onEnterAction property. +func (o *AttributeWidget) OnEnterAction() element.Element { + return o.onEnterAction.Get() +} + +// SetOnEnterAction sets the value of the onEnterAction property. +func (o *AttributeWidget) SetOnEnterAction(v element.Element) { + o.onEnterAction.Set(v) +} + +// OnLeaveAction returns the value of the onLeaveAction property. +func (o *AttributeWidget) OnLeaveAction() element.Element { + return o.onLeaveAction.Get() +} + +// SetOnLeaveAction sets the value of the onLeaveAction property. +func (o *AttributeWidget) SetOnLeaveAction(v element.Element) { + o.onLeaveAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *AttributeWidget) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *AttributeWidget) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// AriaRequired returns the value of the ariaRequired property. +func (o *AttributeWidget) AriaRequired() bool { + return o.ariaRequired.Get() +} + +// SetAriaRequired sets the value of the ariaRequired property. +func (o *AttributeWidget) SetAriaRequired(v bool) { + o.ariaRequired.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AttributeWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + o.required.Init(raw) + if child, err := codec.DecodeChild(raw, "RequiredMessage"); err == nil { + o.requiredMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Validation"); err == nil { + o.validation.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterMicroflowSettings"); err == nil { + o.onEnterMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveMicroflowSettings"); err == nil { + o.onLeaveMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterAction"); err == nil { + o.onEnterAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveAction"); err == nil { + o.onLeaveAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.ariaRequired.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// AttributeWidgetWithPlaceholder +// ──────────────────────────────────────────────────────── + +type AttributeWidgetWithPlaceholder struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + required *property.Primitive[bool] + requiredMessage *property.Part[element.Element] + validation *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onEnterMicroflowSettings *property.Part[element.Element] + onLeaveMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + onEnterAction *property.Part[element.Element] + onLeaveAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + ariaRequired *property.Primitive[bool] + placeholder *property.Part[element.Element] + placeholderTemplate *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *AttributeWidgetWithPlaceholder) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *AttributeWidgetWithPlaceholder) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *AttributeWidgetWithPlaceholder) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *AttributeWidgetWithPlaceholder) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *AttributeWidgetWithPlaceholder) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *AttributeWidgetWithPlaceholder) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *AttributeWidgetWithPlaceholder) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *AttributeWidgetWithPlaceholder) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *AttributeWidgetWithPlaceholder) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *AttributeWidgetWithPlaceholder) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *AttributeWidgetWithPlaceholder) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *AttributeWidgetWithPlaceholder) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *AttributeWidgetWithPlaceholder) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *AttributeWidgetWithPlaceholder) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *AttributeWidgetWithPlaceholder) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *AttributeWidgetWithPlaceholder) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *AttributeWidgetWithPlaceholder) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *AttributeWidgetWithPlaceholder) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *AttributeWidgetWithPlaceholder) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *AttributeWidgetWithPlaceholder) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *AttributeWidgetWithPlaceholder) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *AttributeWidgetWithPlaceholder) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *AttributeWidgetWithPlaceholder) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *AttributeWidgetWithPlaceholder) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *AttributeWidgetWithPlaceholder) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *AttributeWidgetWithPlaceholder) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *AttributeWidgetWithPlaceholder) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *AttributeWidgetWithPlaceholder) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *AttributeWidgetWithPlaceholder) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *AttributeWidgetWithPlaceholder) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// Required returns the value of the required property. +func (o *AttributeWidgetWithPlaceholder) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *AttributeWidgetWithPlaceholder) SetRequired(v bool) { + o.required.Set(v) +} + +// RequiredMessage returns the value of the requiredMessage property. +func (o *AttributeWidgetWithPlaceholder) RequiredMessage() element.Element { + return o.requiredMessage.Get() +} + +// SetRequiredMessage sets the value of the requiredMessage property. +func (o *AttributeWidgetWithPlaceholder) SetRequiredMessage(v element.Element) { + o.requiredMessage.Set(v) +} + +// Validation returns the value of the validation property. +func (o *AttributeWidgetWithPlaceholder) Validation() element.Element { + return o.validation.Get() +} + +// SetValidation sets the value of the validation property. +func (o *AttributeWidgetWithPlaceholder) SetValidation(v element.Element) { + o.validation.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *AttributeWidgetWithPlaceholder) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *AttributeWidgetWithPlaceholder) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnEnterMicroflowSettings returns the value of the onEnterMicroflowSettings property. +func (o *AttributeWidgetWithPlaceholder) OnEnterMicroflowSettings() element.Element { + return o.onEnterMicroflowSettings.Get() +} + +// SetOnEnterMicroflowSettings sets the value of the onEnterMicroflowSettings property. +func (o *AttributeWidgetWithPlaceholder) SetOnEnterMicroflowSettings(v element.Element) { + o.onEnterMicroflowSettings.Set(v) +} + +// OnLeaveMicroflowSettings returns the value of the onLeaveMicroflowSettings property. +func (o *AttributeWidgetWithPlaceholder) OnLeaveMicroflowSettings() element.Element { + return o.onLeaveMicroflowSettings.Get() +} + +// SetOnLeaveMicroflowSettings sets the value of the onLeaveMicroflowSettings property. +func (o *AttributeWidgetWithPlaceholder) SetOnLeaveMicroflowSettings(v element.Element) { + o.onLeaveMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *AttributeWidgetWithPlaceholder) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *AttributeWidgetWithPlaceholder) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// OnEnterAction returns the value of the onEnterAction property. +func (o *AttributeWidgetWithPlaceholder) OnEnterAction() element.Element { + return o.onEnterAction.Get() +} + +// SetOnEnterAction sets the value of the onEnterAction property. +func (o *AttributeWidgetWithPlaceholder) SetOnEnterAction(v element.Element) { + o.onEnterAction.Set(v) +} + +// OnLeaveAction returns the value of the onLeaveAction property. +func (o *AttributeWidgetWithPlaceholder) OnLeaveAction() element.Element { + return o.onLeaveAction.Get() +} + +// SetOnLeaveAction sets the value of the onLeaveAction property. +func (o *AttributeWidgetWithPlaceholder) SetOnLeaveAction(v element.Element) { + o.onLeaveAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *AttributeWidgetWithPlaceholder) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *AttributeWidgetWithPlaceholder) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// AriaRequired returns the value of the ariaRequired property. +func (o *AttributeWidgetWithPlaceholder) AriaRequired() bool { + return o.ariaRequired.Get() +} + +// SetAriaRequired sets the value of the ariaRequired property. +func (o *AttributeWidgetWithPlaceholder) SetAriaRequired(v bool) { + o.ariaRequired.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *AttributeWidgetWithPlaceholder) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *AttributeWidgetWithPlaceholder) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// PlaceholderTemplate returns the value of the placeholderTemplate property. +func (o *AttributeWidgetWithPlaceholder) PlaceholderTemplate() element.Element { + return o.placeholderTemplate.Get() +} + +// SetPlaceholderTemplate sets the value of the placeholderTemplate property. +func (o *AttributeWidgetWithPlaceholder) SetPlaceholderTemplate(v element.Element) { + o.placeholderTemplate.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AttributeWidgetWithPlaceholder) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + o.required.Init(raw) + if child, err := codec.DecodeChild(raw, "RequiredMessage"); err == nil { + o.requiredMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Validation"); err == nil { + o.validation.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterMicroflowSettings"); err == nil { + o.onEnterMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveMicroflowSettings"); err == nil { + o.onLeaveMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterAction"); err == nil { + o.onEnterAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveAction"); err == nil { + o.onLeaveAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.ariaRequired.Init(raw) + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "PlaceholderTemplate"); err == nil { + o.placeholderTemplate.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// BackButton +// ──────────────────────────────────────────────────────── + +type BackButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *BackButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *BackButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *BackButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *BackButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *BackButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *BackButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *BackButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *BackButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *BackButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *BackButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *BackButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *BackButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *BackButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *BackButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *BackButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *BackButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *BackButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *BackButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *BackButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *BackButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *BackButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *BackButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *BackButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *BackButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BackButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// FormBase +// ──────────────────────────────────────────────────────── + +type FormBase struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + canvasWidth *property.Primitive[int32] + canvasHeight *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *FormBase) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *FormBase) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *FormBase) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *FormBase) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *FormBase) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *FormBase) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *FormBase) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *FormBase) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CanvasWidth returns the value of the canvasWidth property. +func (o *FormBase) CanvasWidth() int32 { + return o.canvasWidth.Get() +} + +// SetCanvasWidth sets the value of the canvasWidth property. +func (o *FormBase) SetCanvasWidth(v int32) { + o.canvasWidth.Set(v) +} + +// CanvasHeight returns the value of the canvasHeight property. +func (o *FormBase) CanvasHeight() int32 { + return o.canvasHeight.Get() +} + +// SetCanvasHeight sets the value of the canvasHeight property. +func (o *FormBase) SetCanvasHeight(v int32) { + o.canvasHeight.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FormBase) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.canvasWidth.Init(raw) + o.canvasHeight.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TemplateFormBase +// ──────────────────────────────────────────────────────── + +type TemplateFormBase struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + canvasWidth *property.Primitive[int32] + canvasHeight *property.Primitive[int32] + displayName *property.Primitive[string] + documentationUrl *property.Primitive[string] + templateCategory *property.Primitive[string] + templateCategoryWeight *property.Primitive[int32] + imageData *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *TemplateFormBase) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TemplateFormBase) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *TemplateFormBase) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *TemplateFormBase) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *TemplateFormBase) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *TemplateFormBase) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *TemplateFormBase) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *TemplateFormBase) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CanvasWidth returns the value of the canvasWidth property. +func (o *TemplateFormBase) CanvasWidth() int32 { + return o.canvasWidth.Get() +} + +// SetCanvasWidth sets the value of the canvasWidth property. +func (o *TemplateFormBase) SetCanvasWidth(v int32) { + o.canvasWidth.Set(v) +} + +// CanvasHeight returns the value of the canvasHeight property. +func (o *TemplateFormBase) CanvasHeight() int32 { + return o.canvasHeight.Get() +} + +// SetCanvasHeight sets the value of the canvasHeight property. +func (o *TemplateFormBase) SetCanvasHeight(v int32) { + o.canvasHeight.Set(v) +} + +// DisplayName returns the value of the displayName property. +func (o *TemplateFormBase) DisplayName() string { + return o.displayName.Get() +} + +// SetDisplayName sets the value of the displayName property. +func (o *TemplateFormBase) SetDisplayName(v string) { + o.displayName.Set(v) +} + +// DocumentationUrl returns the value of the documentationUrl property. +func (o *TemplateFormBase) DocumentationUrl() string { + return o.documentationUrl.Get() +} + +// SetDocumentationUrl sets the value of the documentationUrl property. +func (o *TemplateFormBase) SetDocumentationUrl(v string) { + o.documentationUrl.Set(v) +} + +// TemplateCategory returns the value of the templateCategory property. +func (o *TemplateFormBase) TemplateCategory() string { + return o.templateCategory.Get() +} + +// SetTemplateCategory sets the value of the templateCategory property. +func (o *TemplateFormBase) SetTemplateCategory(v string) { + o.templateCategory.Set(v) +} + +// TemplateCategoryWeight returns the value of the templateCategoryWeight property. +func (o *TemplateFormBase) TemplateCategoryWeight() int32 { + return o.templateCategoryWeight.Get() +} + +// SetTemplateCategoryWeight sets the value of the templateCategoryWeight property. +func (o *TemplateFormBase) SetTemplateCategoryWeight(v int32) { + o.templateCategoryWeight.Set(v) +} + +// ImageData returns the value of the imageData property. +func (o *TemplateFormBase) ImageData() string { + return o.imageData.Get() +} + +// SetImageData sets the value of the imageData property. +func (o *TemplateFormBase) SetImageData(v string) { + o.imageData.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TemplateFormBase) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.canvasWidth.Init(raw) + o.canvasHeight.Init(raw) + o.displayName.Init(raw) + o.documentationUrl.Init(raw) + o.templateCategory.Init(raw) + o.templateCategoryWeight.Init(raw) + o.imageData.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// BuildingBlock +// ──────────────────────────────────────────────────────── + +type BuildingBlock struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + canvasWidth *property.Primitive[int32] + canvasHeight *property.Primitive[int32] + displayName *property.Primitive[string] + documentationUrl *property.Primitive[string] + templateCategory *property.Primitive[string] + templateCategoryWeight *property.Primitive[int32] + imageData *property.Primitive[string] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + platform *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *BuildingBlock) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *BuildingBlock) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *BuildingBlock) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *BuildingBlock) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *BuildingBlock) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *BuildingBlock) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *BuildingBlock) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *BuildingBlock) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CanvasWidth returns the value of the canvasWidth property. +func (o *BuildingBlock) CanvasWidth() int32 { + return o.canvasWidth.Get() +} + +// SetCanvasWidth sets the value of the canvasWidth property. +func (o *BuildingBlock) SetCanvasWidth(v int32) { + o.canvasWidth.Set(v) +} + +// CanvasHeight returns the value of the canvasHeight property. +func (o *BuildingBlock) CanvasHeight() int32 { + return o.canvasHeight.Get() +} + +// SetCanvasHeight sets the value of the canvasHeight property. +func (o *BuildingBlock) SetCanvasHeight(v int32) { + o.canvasHeight.Set(v) +} + +// DisplayName returns the value of the displayName property. +func (o *BuildingBlock) DisplayName() string { + return o.displayName.Get() +} + +// SetDisplayName sets the value of the displayName property. +func (o *BuildingBlock) SetDisplayName(v string) { + o.displayName.Set(v) +} + +// DocumentationUrl returns the value of the documentationUrl property. +func (o *BuildingBlock) DocumentationUrl() string { + return o.documentationUrl.Get() +} + +// SetDocumentationUrl sets the value of the documentationUrl property. +func (o *BuildingBlock) SetDocumentationUrl(v string) { + o.documentationUrl.Set(v) +} + +// TemplateCategory returns the value of the templateCategory property. +func (o *BuildingBlock) TemplateCategory() string { + return o.templateCategory.Get() +} + +// SetTemplateCategory sets the value of the templateCategory property. +func (o *BuildingBlock) SetTemplateCategory(v string) { + o.templateCategory.Set(v) +} + +// TemplateCategoryWeight returns the value of the templateCategoryWeight property. +func (o *BuildingBlock) TemplateCategoryWeight() int32 { + return o.templateCategoryWeight.Get() +} + +// SetTemplateCategoryWeight sets the value of the templateCategoryWeight property. +func (o *BuildingBlock) SetTemplateCategoryWeight(v int32) { + o.templateCategoryWeight.Set(v) +} + +// ImageData returns the value of the imageData property. +func (o *BuildingBlock) ImageData() string { + return o.imageData.Get() +} + +// SetImageData sets the value of the imageData property. +func (o *BuildingBlock) SetImageData(v string) { + o.imageData.Set(v) +} + +// Widget returns the value of the widget property. +func (o *BuildingBlock) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *BuildingBlock) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *BuildingBlock) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *BuildingBlock) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *BuildingBlock) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// Platform returns the value of the platform property. +func (o *BuildingBlock) Platform() string { + return o.platform.Get() +} + +// SetPlatform sets the value of the platform property. +func (o *BuildingBlock) SetPlatform(v string) { + o.platform.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BuildingBlock) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.canvasWidth.Init(raw) + o.canvasHeight.Init(raw) + o.displayName.Init(raw) + o.documentationUrl.Init(raw) + o.templateCategory.Init(raw) + o.templateCategoryWeight.Init(raw) + o.imageData.Init(raw) + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Platform"); err == nil { + if s, ok := val.StringValueOK(); ok { o.platform.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ClientAction +// ──────────────────────────────────────────────────────── + +type ClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *ClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *ClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CallNanoflowClientAction +// ──────────────────────────────────────────────────────── + +type CallNanoflowClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + nanoflow *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] + progressBar *property.Enum[string] + progressMessage *property.Part[element.Element] + confirmationInfo *property.Part[element.Element] + outputMappings *property.PartList[element.Element] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *CallNanoflowClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *CallNanoflowClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// NanoflowQualifiedName returns the value of the nanoflow property. +func (o *CallNanoflowClientAction) NanoflowQualifiedName() string { + return o.nanoflow.QualifiedName() +} + +// SetNanoflowQualifiedName sets the value of the nanoflow property. +func (o *CallNanoflowClientAction) SetNanoflowQualifiedName(v string) { + o.nanoflow.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *CallNanoflowClientAction) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *CallNanoflowClientAction) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *CallNanoflowClientAction) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// ProgressBar returns the value of the progressBar property. +func (o *CallNanoflowClientAction) ProgressBar() string { + return o.progressBar.Get() +} + +// SetProgressBar sets the value of the progressBar property. +func (o *CallNanoflowClientAction) SetProgressBar(v string) { + o.progressBar.Set(v) +} + +// ProgressMessage returns the value of the progressMessage property. +func (o *CallNanoflowClientAction) ProgressMessage() element.Element { + return o.progressMessage.Get() +} + +// SetProgressMessage sets the value of the progressMessage property. +func (o *CallNanoflowClientAction) SetProgressMessage(v element.Element) { + o.progressMessage.Set(v) +} + +// ConfirmationInfo returns the value of the confirmationInfo property. +func (o *CallNanoflowClientAction) ConfirmationInfo() element.Element { + return o.confirmationInfo.Get() +} + +// SetConfirmationInfo sets the value of the confirmationInfo property. +func (o *CallNanoflowClientAction) SetConfirmationInfo(v element.Element) { + o.confirmationInfo.Set(v) +} + +// OutputMappingsItems returns the value of the outputMappings property. +func (o *CallNanoflowClientAction) OutputMappingsItems() []element.Element { + return o.outputMappings.Items() +} + +// AddOutputMappings appends a child element to the outputMappings list. +func (o *CallNanoflowClientAction) AddOutputMappings(v element.Element) { + o.outputMappings.Append(v) +} + +// RemoveOutputMappings removes the element at the given index from the outputMappings list. +func (o *CallNanoflowClientAction) RemoveOutputMappings(index int) { + o.outputMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CallNanoflowClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + if val, err := raw.LookupErr("Nanoflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.nanoflow.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("ProgressBar"); err == nil { + if s, ok := val.StringValueOK(); ok { o.progressBar.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ProgressMessage"); err == nil { + o.progressMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConfirmationInfo"); err == nil { + o.confirmationInfo.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "OutputMappings"); err == nil { + for _, child := range children { + o.outputMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// CallWorkflowClientAction +// ──────────────────────────────────────────────────────── + +type CallWorkflowClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + workflow *property.ByNameRef[element.Element] + closePage *property.Primitive[bool] + commit *property.Primitive[bool] + confirmationInfo *property.Part[element.Element] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *CallWorkflowClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *CallWorkflowClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// WorkflowQualifiedName returns the value of the workflow property. +func (o *CallWorkflowClientAction) WorkflowQualifiedName() string { + return o.workflow.QualifiedName() +} + +// SetWorkflowQualifiedName sets the value of the workflow property. +func (o *CallWorkflowClientAction) SetWorkflowQualifiedName(v string) { + o.workflow.SetQualifiedName(v) +} + +// ClosePage returns the value of the closePage property. +func (o *CallWorkflowClientAction) ClosePage() bool { + return o.closePage.Get() +} + +// SetClosePage sets the value of the closePage property. +func (o *CallWorkflowClientAction) SetClosePage(v bool) { + o.closePage.Set(v) +} + +// Commit returns the value of the commit property. +func (o *CallWorkflowClientAction) Commit() bool { + return o.commit.Get() +} + +// SetCommit sets the value of the commit property. +func (o *CallWorkflowClientAction) SetCommit(v bool) { + o.commit.Set(v) +} + +// ConfirmationInfo returns the value of the confirmationInfo property. +func (o *CallWorkflowClientAction) ConfirmationInfo() element.Element { + return o.confirmationInfo.Get() +} + +// SetConfirmationInfo sets the value of the confirmationInfo property. +func (o *CallWorkflowClientAction) SetConfirmationInfo(v element.Element) { + o.confirmationInfo.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CallWorkflowClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + if val, err := raw.LookupErr("Workflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.workflow.SetFromDecode(s) } + } + o.closePage.Init(raw) + o.commit.Init(raw) + if child, err := codec.DecodeChild(raw, "ConfirmationInfo"); err == nil { + o.confirmationInfo.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// CancelButton +// ──────────────────────────────────────────────────────── + +type CancelButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] + closePage *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *CancelButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CancelButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *CancelButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *CancelButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *CancelButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *CancelButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *CancelButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *CancelButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *CancelButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *CancelButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *CancelButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *CancelButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *CancelButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *CancelButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *CancelButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *CancelButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *CancelButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *CancelButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *CancelButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *CancelButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *CancelButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *CancelButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *CancelButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *CancelButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// ClosePage returns the value of the closePage property. +func (o *CancelButton) ClosePage() bool { + return o.closePage.Get() +} + +// SetClosePage sets the value of the closePage property. +func (o *CancelButton) SetClosePage(v bool) { + o.closePage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CancelButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + o.closePage.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CancelChangesClientAction +// ──────────────────────────────────────────────────────── + +type CancelChangesClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + closePage *property.Primitive[bool] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *CancelChangesClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *CancelChangesClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// ClosePage returns the value of the closePage property. +func (o *CancelChangesClientAction) ClosePage() bool { + return o.closePage.Get() +} + +// SetClosePage sets the value of the closePage property. +func (o *CancelChangesClientAction) SetClosePage(v bool) { + o.closePage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CancelChangesClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + o.closePage.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CancelSynchronizationClientAction +// ──────────────────────────────────────────────────────── + +type CancelSynchronizationClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *CancelSynchronizationClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *CancelSynchronizationClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CancelSynchronizationClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CheckBox +// ──────────────────────────────────────────────────────── + +type CheckBox struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + required *property.Primitive[bool] + requiredMessage *property.Part[element.Element] + validation *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onEnterMicroflowSettings *property.Part[element.Element] + onLeaveMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + onEnterAction *property.Part[element.Element] + onLeaveAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + ariaRequired *property.Primitive[bool] + labelPosition *property.Enum[string] + nativeRenderMode *property.Enum[string] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *CheckBox) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CheckBox) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *CheckBox) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *CheckBox) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *CheckBox) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *CheckBox) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *CheckBox) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *CheckBox) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *CheckBox) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *CheckBox) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *CheckBox) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *CheckBox) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *CheckBox) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *CheckBox) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *CheckBox) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *CheckBox) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *CheckBox) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *CheckBox) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *CheckBox) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *CheckBox) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *CheckBox) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *CheckBox) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *CheckBox) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *CheckBox) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *CheckBox) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *CheckBox) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *CheckBox) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *CheckBox) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *CheckBox) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *CheckBox) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// Required returns the value of the required property. +func (o *CheckBox) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *CheckBox) SetRequired(v bool) { + o.required.Set(v) +} + +// RequiredMessage returns the value of the requiredMessage property. +func (o *CheckBox) RequiredMessage() element.Element { + return o.requiredMessage.Get() +} + +// SetRequiredMessage sets the value of the requiredMessage property. +func (o *CheckBox) SetRequiredMessage(v element.Element) { + o.requiredMessage.Set(v) +} + +// Validation returns the value of the validation property. +func (o *CheckBox) Validation() element.Element { + return o.validation.Get() +} + +// SetValidation sets the value of the validation property. +func (o *CheckBox) SetValidation(v element.Element) { + o.validation.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *CheckBox) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *CheckBox) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnEnterMicroflowSettings returns the value of the onEnterMicroflowSettings property. +func (o *CheckBox) OnEnterMicroflowSettings() element.Element { + return o.onEnterMicroflowSettings.Get() +} + +// SetOnEnterMicroflowSettings sets the value of the onEnterMicroflowSettings property. +func (o *CheckBox) SetOnEnterMicroflowSettings(v element.Element) { + o.onEnterMicroflowSettings.Set(v) +} + +// OnLeaveMicroflowSettings returns the value of the onLeaveMicroflowSettings property. +func (o *CheckBox) OnLeaveMicroflowSettings() element.Element { + return o.onLeaveMicroflowSettings.Get() +} + +// SetOnLeaveMicroflowSettings sets the value of the onLeaveMicroflowSettings property. +func (o *CheckBox) SetOnLeaveMicroflowSettings(v element.Element) { + o.onLeaveMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *CheckBox) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *CheckBox) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// OnEnterAction returns the value of the onEnterAction property. +func (o *CheckBox) OnEnterAction() element.Element { + return o.onEnterAction.Get() +} + +// SetOnEnterAction sets the value of the onEnterAction property. +func (o *CheckBox) SetOnEnterAction(v element.Element) { + o.onEnterAction.Set(v) +} + +// OnLeaveAction returns the value of the onLeaveAction property. +func (o *CheckBox) OnLeaveAction() element.Element { + return o.onLeaveAction.Get() +} + +// SetOnLeaveAction sets the value of the onLeaveAction property. +func (o *CheckBox) SetOnLeaveAction(v element.Element) { + o.onLeaveAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *CheckBox) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *CheckBox) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// AriaRequired returns the value of the ariaRequired property. +func (o *CheckBox) AriaRequired() bool { + return o.ariaRequired.Get() +} + +// SetAriaRequired sets the value of the ariaRequired property. +func (o *CheckBox) SetAriaRequired(v bool) { + o.ariaRequired.Set(v) +} + +// LabelPosition returns the value of the labelPosition property. +func (o *CheckBox) LabelPosition() string { + return o.labelPosition.Get() +} + +// SetLabelPosition sets the value of the labelPosition property. +func (o *CheckBox) SetLabelPosition(v string) { + o.labelPosition.Set(v) +} + +// NativeRenderMode returns the value of the nativeRenderMode property. +func (o *CheckBox) NativeRenderMode() string { + return o.nativeRenderMode.Get() +} + +// SetNativeRenderMode sets the value of the nativeRenderMode property. +func (o *CheckBox) SetNativeRenderMode(v string) { + o.nativeRenderMode.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *CheckBox) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *CheckBox) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CheckBox) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + o.required.Init(raw) + if child, err := codec.DecodeChild(raw, "RequiredMessage"); err == nil { + o.requiredMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Validation"); err == nil { + o.validation.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterMicroflowSettings"); err == nil { + o.onEnterMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveMicroflowSettings"); err == nil { + o.onLeaveMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterAction"); err == nil { + o.onEnterAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveAction"); err == nil { + o.onLeaveAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.ariaRequired.Init(raw) + if val, err := raw.LookupErr("LabelPosition"); err == nil { + if s, ok := val.StringValueOK(); ok { o.labelPosition.SetFromDecode(s) } + } + if val, err := raw.LookupErr("NativeRenderMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.nativeRenderMode.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ClientTemplate +// ──────────────────────────────────────────────────────── + +type ClientTemplate struct { + element.Base + template *property.Part[element.Element] + parameters *property.PartList[element.Element] + fallback *property.Part[element.Element] +} + +// Template returns the value of the template property. +func (o *ClientTemplate) Template() element.Element { + return o.template.Get() +} + +// SetTemplate sets the value of the template property. +func (o *ClientTemplate) SetTemplate(v element.Element) { + o.template.Set(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *ClientTemplate) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *ClientTemplate) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *ClientTemplate) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// Fallback returns the value of the fallback property. +func (o *ClientTemplate) Fallback() element.Element { + return o.fallback.Get() +} + +// SetFallback sets the value of the fallback property. +func (o *ClientTemplate) SetFallback(v element.Element) { + o.fallback.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ClientTemplate) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Template"); err == nil { + o.template.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Fallback"); err == nil { + o.fallback.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ClientTemplateParameter +// ──────────────────────────────────────────────────────── + +type ClientTemplateParameter struct { + element.Base + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + expression *property.Primitive[string] + formattingInfo *property.Part[element.Element] + sourceVariable *property.Part[element.Element] +} + +// AttributePath returns the value of the attributePath property. +func (o *ClientTemplateParameter) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *ClientTemplateParameter) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *ClientTemplateParameter) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *ClientTemplateParameter) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// Expression returns the value of the expression property. +func (o *ClientTemplateParameter) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *ClientTemplateParameter) SetExpression(v string) { + o.expression.Set(v) +} + +// FormattingInfo returns the value of the formattingInfo property. +func (o *ClientTemplateParameter) FormattingInfo() element.Element { + return o.formattingInfo.Get() +} + +// SetFormattingInfo sets the value of the formattingInfo property. +func (o *ClientTemplateParameter) SetFormattingInfo(v element.Element) { + o.formattingInfo.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ClientTemplateParameter) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ClientTemplateParameter) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ClientTemplateParameter) InitFromRaw(raw bson.Raw) { + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "FormattingInfo"); err == nil { + o.formattingInfo.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ClosePageClientAction +// ──────────────────────────────────────────────────────── + +type ClosePageClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + numberOfPages *property.Primitive[int32] + numberOfPagesToClose *property.Primitive[string] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *ClosePageClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *ClosePageClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// NumberOfPages returns the value of the numberOfPages property. +func (o *ClosePageClientAction) NumberOfPages() int32 { + return o.numberOfPages.Get() +} + +// SetNumberOfPages sets the value of the numberOfPages property. +func (o *ClosePageClientAction) SetNumberOfPages(v int32) { + o.numberOfPages.Set(v) +} + +// NumberOfPagesToClose returns the value of the numberOfPagesToClose property. +func (o *ClosePageClientAction) NumberOfPagesToClose() string { + return o.numberOfPagesToClose.Get() +} + +// SetNumberOfPagesToClose sets the value of the numberOfPagesToClose property. +func (o *ClosePageClientAction) SetNumberOfPagesToClose(v string) { + o.numberOfPagesToClose.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ClosePageClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + o.numberOfPages.Init(raw) + o.numberOfPagesToClose.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EntityWidget +// ──────────────────────────────────────────────────────── + +type EntityWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + dataSource *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *EntityWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *EntityWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *EntityWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *EntityWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *EntityWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *EntityWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *EntityWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *EntityWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *EntityWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *EntityWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *EntityWidget) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *EntityWidget) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *EntityWidget) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *EntityWidget) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// DataSource returns the value of the dataSource property. +func (o *EntityWidget) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *EntityWidget) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EntityWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ListenTargetWidget +// ──────────────────────────────────────────────────────── + +type ListenTargetWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + dataSource *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *ListenTargetWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ListenTargetWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ListenTargetWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ListenTargetWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ListenTargetWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ListenTargetWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ListenTargetWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ListenTargetWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ListenTargetWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ListenTargetWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *ListenTargetWidget) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *ListenTargetWidget) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *ListenTargetWidget) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *ListenTargetWidget) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// DataSource returns the value of the dataSource property. +func (o *ListenTargetWidget) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *ListenTargetWidget) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListenTargetWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Grid +// ──────────────────────────────────────────────────────── + +type Grid struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + dataSource *property.Part[element.Element] + isControlBarVisible *property.Primitive[bool] + isPagingEnabled *property.Primitive[bool] + showPagingBar *property.Enum[string] + selectionMode *property.Enum[string] + selectFirst *property.Primitive[bool] + defaultButtonTrigger *property.Enum[string] + refreshTime *property.Primitive[int32] + controlBar *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *Grid) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Grid) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *Grid) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Grid) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Grid) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Grid) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *Grid) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *Grid) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *Grid) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *Grid) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *Grid) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *Grid) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *Grid) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *Grid) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// DataSource returns the value of the dataSource property. +func (o *Grid) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *Grid) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// IsControlBarVisible returns the value of the isControlBarVisible property. +func (o *Grid) IsControlBarVisible() bool { + return o.isControlBarVisible.Get() +} + +// SetIsControlBarVisible sets the value of the isControlBarVisible property. +func (o *Grid) SetIsControlBarVisible(v bool) { + o.isControlBarVisible.Set(v) +} + +// IsPagingEnabled returns the value of the isPagingEnabled property. +func (o *Grid) IsPagingEnabled() bool { + return o.isPagingEnabled.Get() +} + +// SetIsPagingEnabled sets the value of the isPagingEnabled property. +func (o *Grid) SetIsPagingEnabled(v bool) { + o.isPagingEnabled.Set(v) +} + +// ShowPagingBar returns the value of the showPagingBar property. +func (o *Grid) ShowPagingBar() string { + return o.showPagingBar.Get() +} + +// SetShowPagingBar sets the value of the showPagingBar property. +func (o *Grid) SetShowPagingBar(v string) { + o.showPagingBar.Set(v) +} + +// SelectionMode returns the value of the selectionMode property. +func (o *Grid) SelectionMode() string { + return o.selectionMode.Get() +} + +// SetSelectionMode sets the value of the selectionMode property. +func (o *Grid) SetSelectionMode(v string) { + o.selectionMode.Set(v) +} + +// SelectFirst returns the value of the selectFirst property. +func (o *Grid) SelectFirst() bool { + return o.selectFirst.Get() +} + +// SetSelectFirst sets the value of the selectFirst property. +func (o *Grid) SetSelectFirst(v bool) { + o.selectFirst.Set(v) +} + +// DefaultButtonTrigger returns the value of the defaultButtonTrigger property. +func (o *Grid) DefaultButtonTrigger() string { + return o.defaultButtonTrigger.Get() +} + +// SetDefaultButtonTrigger sets the value of the defaultButtonTrigger property. +func (o *Grid) SetDefaultButtonTrigger(v string) { + o.defaultButtonTrigger.Set(v) +} + +// RefreshTime returns the value of the refreshTime property. +func (o *Grid) RefreshTime() int32 { + return o.refreshTime.Get() +} + +// SetRefreshTime sets the value of the refreshTime property. +func (o *Grid) SetRefreshTime(v int32) { + o.refreshTime.Set(v) +} + +// ControlBar returns the value of the controlBar property. +func (o *Grid) ControlBar() element.Element { + return o.controlBar.Get() +} + +// SetControlBar sets the value of the controlBar property. +func (o *Grid) SetControlBar(v element.Element) { + o.controlBar.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Grid) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } + o.isControlBarVisible.Init(raw) + o.isPagingEnabled.Init(raw) + if val, err := raw.LookupErr("ShowPagingBar"); err == nil { + if s, ok := val.StringValueOK(); ok { o.showPagingBar.SetFromDecode(s) } + } + if val, err := raw.LookupErr("SelectionMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.selectionMode.SetFromDecode(s) } + } + o.selectFirst.Init(raw) + if val, err := raw.LookupErr("DefaultButtonTrigger"); err == nil { + if s, ok := val.StringValueOK(); ok { o.defaultButtonTrigger.SetFromDecode(s) } + } + o.refreshTime.Init(raw) + if child, err := codec.DecodeChild(raw, "ControlBar"); err == nil { + o.controlBar.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ColumnGrid +// ──────────────────────────────────────────────────────── + +type ColumnGrid struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + dataSource *property.Part[element.Element] + isControlBarVisible *property.Primitive[bool] + isPagingEnabled *property.Primitive[bool] + showPagingBar *property.Enum[string] + selectionMode *property.Enum[string] + selectFirst *property.Primitive[bool] + defaultButtonTrigger *property.Enum[string] + refreshTime *property.Primitive[int32] + controlBar *property.Part[element.Element] + columns *property.PartList[element.Element] + numberOfRows *property.Primitive[int32] + showEmptyRows *property.Primitive[bool] + widthUnit *property.Enum[string] + tooltipPage *property.ByNameRef[element.Element] +} + +// Name returns the value of the name property. +func (o *ColumnGrid) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ColumnGrid) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ColumnGrid) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ColumnGrid) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ColumnGrid) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ColumnGrid) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ColumnGrid) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ColumnGrid) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ColumnGrid) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ColumnGrid) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *ColumnGrid) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *ColumnGrid) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *ColumnGrid) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *ColumnGrid) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// DataSource returns the value of the dataSource property. +func (o *ColumnGrid) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *ColumnGrid) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// IsControlBarVisible returns the value of the isControlBarVisible property. +func (o *ColumnGrid) IsControlBarVisible() bool { + return o.isControlBarVisible.Get() +} + +// SetIsControlBarVisible sets the value of the isControlBarVisible property. +func (o *ColumnGrid) SetIsControlBarVisible(v bool) { + o.isControlBarVisible.Set(v) +} + +// IsPagingEnabled returns the value of the isPagingEnabled property. +func (o *ColumnGrid) IsPagingEnabled() bool { + return o.isPagingEnabled.Get() +} + +// SetIsPagingEnabled sets the value of the isPagingEnabled property. +func (o *ColumnGrid) SetIsPagingEnabled(v bool) { + o.isPagingEnabled.Set(v) +} + +// ShowPagingBar returns the value of the showPagingBar property. +func (o *ColumnGrid) ShowPagingBar() string { + return o.showPagingBar.Get() +} + +// SetShowPagingBar sets the value of the showPagingBar property. +func (o *ColumnGrid) SetShowPagingBar(v string) { + o.showPagingBar.Set(v) +} + +// SelectionMode returns the value of the selectionMode property. +func (o *ColumnGrid) SelectionMode() string { + return o.selectionMode.Get() +} + +// SetSelectionMode sets the value of the selectionMode property. +func (o *ColumnGrid) SetSelectionMode(v string) { + o.selectionMode.Set(v) +} + +// SelectFirst returns the value of the selectFirst property. +func (o *ColumnGrid) SelectFirst() bool { + return o.selectFirst.Get() +} + +// SetSelectFirst sets the value of the selectFirst property. +func (o *ColumnGrid) SetSelectFirst(v bool) { + o.selectFirst.Set(v) +} + +// DefaultButtonTrigger returns the value of the defaultButtonTrigger property. +func (o *ColumnGrid) DefaultButtonTrigger() string { + return o.defaultButtonTrigger.Get() +} + +// SetDefaultButtonTrigger sets the value of the defaultButtonTrigger property. +func (o *ColumnGrid) SetDefaultButtonTrigger(v string) { + o.defaultButtonTrigger.Set(v) +} + +// RefreshTime returns the value of the refreshTime property. +func (o *ColumnGrid) RefreshTime() int32 { + return o.refreshTime.Get() +} + +// SetRefreshTime sets the value of the refreshTime property. +func (o *ColumnGrid) SetRefreshTime(v int32) { + o.refreshTime.Set(v) +} + +// ControlBar returns the value of the controlBar property. +func (o *ColumnGrid) ControlBar() element.Element { + return o.controlBar.Get() +} + +// SetControlBar sets the value of the controlBar property. +func (o *ColumnGrid) SetControlBar(v element.Element) { + o.controlBar.Set(v) +} + +// ColumnsItems returns the value of the columns property. +func (o *ColumnGrid) ColumnsItems() []element.Element { + return o.columns.Items() +} + +// AddColumns appends a child element to the columns list. +func (o *ColumnGrid) AddColumns(v element.Element) { + o.columns.Append(v) +} + +// RemoveColumns removes the element at the given index from the columns list. +func (o *ColumnGrid) RemoveColumns(index int) { + o.columns.Remove(index) +} + +// NumberOfRows returns the value of the numberOfRows property. +func (o *ColumnGrid) NumberOfRows() int32 { + return o.numberOfRows.Get() +} + +// SetNumberOfRows sets the value of the numberOfRows property. +func (o *ColumnGrid) SetNumberOfRows(v int32) { + o.numberOfRows.Set(v) +} + +// ShowEmptyRows returns the value of the showEmptyRows property. +func (o *ColumnGrid) ShowEmptyRows() bool { + return o.showEmptyRows.Get() +} + +// SetShowEmptyRows sets the value of the showEmptyRows property. +func (o *ColumnGrid) SetShowEmptyRows(v bool) { + o.showEmptyRows.Set(v) +} + +// WidthUnit returns the value of the widthUnit property. +func (o *ColumnGrid) WidthUnit() string { + return o.widthUnit.Get() +} + +// SetWidthUnit sets the value of the widthUnit property. +func (o *ColumnGrid) SetWidthUnit(v string) { + o.widthUnit.Set(v) +} + +// TooltipPageQualifiedName returns the value of the tooltipPage property. +func (o *ColumnGrid) TooltipPageQualifiedName() string { + return o.tooltipPage.QualifiedName() +} + +// SetTooltipPageQualifiedName sets the value of the tooltipPage property. +func (o *ColumnGrid) SetTooltipPageQualifiedName(v string) { + o.tooltipPage.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ColumnGrid) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } + o.isControlBarVisible.Init(raw) + o.isPagingEnabled.Init(raw) + if val, err := raw.LookupErr("ShowPagingBar"); err == nil { + if s, ok := val.StringValueOK(); ok { o.showPagingBar.SetFromDecode(s) } + } + if val, err := raw.LookupErr("SelectionMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.selectionMode.SetFromDecode(s) } + } + o.selectFirst.Init(raw) + if val, err := raw.LookupErr("DefaultButtonTrigger"); err == nil { + if s, ok := val.StringValueOK(); ok { o.defaultButtonTrigger.SetFromDecode(s) } + } + o.refreshTime.Init(raw) + if child, err := codec.DecodeChild(raw, "ControlBar"); err == nil { + o.controlBar.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Columns"); err == nil { + for _, child := range children { + o.columns.AppendFromDecode(child) + } + } + o.numberOfRows.Init(raw) + o.showEmptyRows.Init(raw) + if val, err := raw.LookupErr("WidthUnit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.widthUnit.SetFromDecode(s) } + } + if val, err := raw.LookupErr("TooltipPage"); err == nil { + if s, ok := val.StringValueOK(); ok { o.tooltipPage.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ControlBarItem +// ──────────────────────────────────────────────────────── + +type ControlBarItem struct { + element.Base + name *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *ControlBarItem) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ControlBarItem) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ControlBarItem) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SearchField +// ──────────────────────────────────────────────────────── + +type SearchField struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + placeholder *property.Part[element.Element] + customDateFormat *property.Primitive[string] + propType *property.Enum[string] + defaultValue *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *SearchField) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SearchField) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *SearchField) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *SearchField) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *SearchField) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *SearchField) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// CustomDateFormat returns the value of the customDateFormat property. +func (o *SearchField) CustomDateFormat() string { + return o.customDateFormat.Get() +} + +// SetCustomDateFormat sets the value of the customDateFormat property. +func (o *SearchField) SetCustomDateFormat(v string) { + o.customDateFormat.Set(v) +} + +// Type returns the value of the type property. +func (o *SearchField) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *SearchField) SetType(v string) { + o.propType.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *SearchField) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *SearchField) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SearchField) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } + o.customDateFormat.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.defaultValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SingleSearchField +// ──────────────────────────────────────────────────────── + +type SingleSearchField struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + placeholder *property.Part[element.Element] + customDateFormat *property.Primitive[string] + propType *property.Enum[string] + defaultValue *property.Primitive[string] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + operator *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *SingleSearchField) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SingleSearchField) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *SingleSearchField) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *SingleSearchField) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *SingleSearchField) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *SingleSearchField) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// CustomDateFormat returns the value of the customDateFormat property. +func (o *SingleSearchField) CustomDateFormat() string { + return o.customDateFormat.Get() +} + +// SetCustomDateFormat sets the value of the customDateFormat property. +func (o *SingleSearchField) SetCustomDateFormat(v string) { + o.customDateFormat.Set(v) +} + +// Type returns the value of the type property. +func (o *SingleSearchField) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *SingleSearchField) SetType(v string) { + o.propType.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *SingleSearchField) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *SingleSearchField) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *SingleSearchField) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *SingleSearchField) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *SingleSearchField) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *SingleSearchField) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// Operator returns the value of the operator property. +func (o *SingleSearchField) Operator() string { + return o.operator.Get() +} + +// SetOperator sets the value of the operator property. +func (o *SingleSearchField) SetOperator(v string) { + o.operator.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SingleSearchField) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } + o.customDateFormat.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.defaultValue.Init(raw) + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("Operator"); err == nil { + if s, ok := val.StringValueOK(); ok { o.operator.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ComparisonSearchField +// ──────────────────────────────────────────────────────── + +type ComparisonSearchField struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + placeholder *property.Part[element.Element] + customDateFormat *property.Primitive[string] + propType *property.Enum[string] + defaultValue *property.Primitive[string] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + operator *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *ComparisonSearchField) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ComparisonSearchField) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ComparisonSearchField) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ComparisonSearchField) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *ComparisonSearchField) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *ComparisonSearchField) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// CustomDateFormat returns the value of the customDateFormat property. +func (o *ComparisonSearchField) CustomDateFormat() string { + return o.customDateFormat.Get() +} + +// SetCustomDateFormat sets the value of the customDateFormat property. +func (o *ComparisonSearchField) SetCustomDateFormat(v string) { + o.customDateFormat.Set(v) +} + +// Type returns the value of the type property. +func (o *ComparisonSearchField) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *ComparisonSearchField) SetType(v string) { + o.propType.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *ComparisonSearchField) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *ComparisonSearchField) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *ComparisonSearchField) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *ComparisonSearchField) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *ComparisonSearchField) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *ComparisonSearchField) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// Operator returns the value of the operator property. +func (o *ComparisonSearchField) Operator() string { + return o.operator.Get() +} + +// SetOperator sets the value of the operator property. +func (o *ComparisonSearchField) SetOperator(v string) { + o.operator.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ComparisonSearchField) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } + o.customDateFormat.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.defaultValue.Init(raw) + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("Operator"); err == nil { + if s, ok := val.StringValueOK(); ok { o.operator.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// CompoundDesignPropertyValue +// ──────────────────────────────────────────────────────── + +type CompoundDesignPropertyValue struct { + element.Base + properties *property.PartList[element.Element] +} + +// PropertiesItems returns the value of the properties property. +func (o *CompoundDesignPropertyValue) PropertiesItems() []element.Element { + return o.properties.Items() +} + +// AddProperties appends a child element to the properties list. +func (o *CompoundDesignPropertyValue) AddProperties(v element.Element) { + o.properties.Append(v) +} + +// RemoveProperties removes the element at the given index from the properties list. +func (o *CompoundDesignPropertyValue) RemoveProperties(index int) { + o.properties.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CompoundDesignPropertyValue) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Properties"); err == nil { + for _, child := range children { + o.properties.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ConditionalSettings +// ──────────────────────────────────────────────────────── + +type ConditionalSettings struct { + element.Base + attribute *property.ByNameRef[element.Element] + conditions *property.PartList[element.Element] + expression *property.Primitive[string] + sourceVariable *property.Part[element.Element] + expressionModel *property.Part[element.Element] +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ConditionalSettings) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ConditionalSettings) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// ConditionsItems returns the value of the conditions property. +func (o *ConditionalSettings) ConditionsItems() []element.Element { + return o.conditions.Items() +} + +// AddConditions appends a child element to the conditions list. +func (o *ConditionalSettings) AddConditions(v element.Element) { + o.conditions.Append(v) +} + +// RemoveConditions removes the element at the given index from the conditions list. +func (o *ConditionalSettings) RemoveConditions(index int) { + o.conditions.Remove(index) +} + +// Expression returns the value of the expression property. +func (o *ConditionalSettings) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *ConditionalSettings) SetExpression(v string) { + o.expression.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ConditionalSettings) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ConditionalSettings) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *ConditionalSettings) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *ConditionalSettings) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConditionalSettings) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Conditions"); err == nil { + for _, child := range children { + o.conditions.AppendFromDecode(child) + } + } + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ConditionalEditabilitySettings +// ──────────────────────────────────────────────────────── + +type ConditionalEditabilitySettings struct { + element.Base + attribute *property.ByNameRef[element.Element] + conditions *property.PartList[element.Element] + expression *property.Primitive[string] + sourceVariable *property.Part[element.Element] + expressionModel *property.Part[element.Element] +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ConditionalEditabilitySettings) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ConditionalEditabilitySettings) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// ConditionsItems returns the value of the conditions property. +func (o *ConditionalEditabilitySettings) ConditionsItems() []element.Element { + return o.conditions.Items() +} + +// AddConditions appends a child element to the conditions list. +func (o *ConditionalEditabilitySettings) AddConditions(v element.Element) { + o.conditions.Append(v) +} + +// RemoveConditions removes the element at the given index from the conditions list. +func (o *ConditionalEditabilitySettings) RemoveConditions(index int) { + o.conditions.Remove(index) +} + +// Expression returns the value of the expression property. +func (o *ConditionalEditabilitySettings) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *ConditionalEditabilitySettings) SetExpression(v string) { + o.expression.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ConditionalEditabilitySettings) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ConditionalEditabilitySettings) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *ConditionalEditabilitySettings) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *ConditionalEditabilitySettings) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConditionalEditabilitySettings) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Conditions"); err == nil { + for _, child := range children { + o.conditions.AppendFromDecode(child) + } + } + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ConditionalVisibilitySettings +// ──────────────────────────────────────────────────────── + +type ConditionalVisibilitySettings struct { + element.Base + attribute *property.ByNameRef[element.Element] + conditions *property.PartList[element.Element] + expression *property.Primitive[string] + sourceVariable *property.Part[element.Element] + expressionModel *property.Part[element.Element] + moduleRoles *property.ByNameRefList[element.Element] + ignoreSecurity *property.Primitive[bool] +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ConditionalVisibilitySettings) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ConditionalVisibilitySettings) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// ConditionsItems returns the value of the conditions property. +func (o *ConditionalVisibilitySettings) ConditionsItems() []element.Element { + return o.conditions.Items() +} + +// AddConditions appends a child element to the conditions list. +func (o *ConditionalVisibilitySettings) AddConditions(v element.Element) { + o.conditions.Append(v) +} + +// RemoveConditions removes the element at the given index from the conditions list. +func (o *ConditionalVisibilitySettings) RemoveConditions(index int) { + o.conditions.Remove(index) +} + +// Expression returns the value of the expression property. +func (o *ConditionalVisibilitySettings) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *ConditionalVisibilitySettings) SetExpression(v string) { + o.expression.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ConditionalVisibilitySettings) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ConditionalVisibilitySettings) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *ConditionalVisibilitySettings) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *ConditionalVisibilitySettings) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// ModuleRolesQualifiedNames returns the value of the moduleRoles property. +func (o *ConditionalVisibilitySettings) ModuleRolesQualifiedNames() []string { + return o.moduleRoles.QualifiedNames() +} + +// SetModuleRolesQualifiedNames sets the value of the moduleRoles property. +func (o *ConditionalVisibilitySettings) SetModuleRolesQualifiedNames(v []string) { + o.moduleRoles.SetQualifiedNames(v) +} + +// AddModuleRoles appends a child element to the moduleRoles list. +func (o *ConditionalVisibilitySettings) AddModuleRoles(v string) { + o.moduleRoles.Append(v) +} + +// IgnoreSecurity returns the value of the ignoreSecurity property. +func (o *ConditionalVisibilitySettings) IgnoreSecurity() bool { + return o.ignoreSecurity.Get() +} + +// SetIgnoreSecurity sets the value of the ignoreSecurity property. +func (o *ConditionalVisibilitySettings) SetIgnoreSecurity(v bool) { + o.ignoreSecurity.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConditionalVisibilitySettings) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Conditions"); err == nil { + for _, child := range children { + o.conditions.AppendFromDecode(child) + } + } + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } + if val, err := raw.LookupErr("ModuleRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.moduleRoles.SetFromDecode(qnames) + } + } + o.ignoreSecurity.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConfirmationInfo +// ──────────────────────────────────────────────────────── + +type ConfirmationInfo struct { + element.Base + question *property.Part[element.Element] + proceedButtonCaption *property.Part[element.Element] + cancelButtonCaption *property.Part[element.Element] +} + +// Question returns the value of the question property. +func (o *ConfirmationInfo) Question() element.Element { + return o.question.Get() +} + +// SetQuestion sets the value of the question property. +func (o *ConfirmationInfo) SetQuestion(v element.Element) { + o.question.Set(v) +} + +// ProceedButtonCaption returns the value of the proceedButtonCaption property. +func (o *ConfirmationInfo) ProceedButtonCaption() element.Element { + return o.proceedButtonCaption.Get() +} + +// SetProceedButtonCaption sets the value of the proceedButtonCaption property. +func (o *ConfirmationInfo) SetProceedButtonCaption(v element.Element) { + o.proceedButtonCaption.Set(v) +} + +// CancelButtonCaption returns the value of the cancelButtonCaption property. +func (o *ConfirmationInfo) CancelButtonCaption() element.Element { + return o.cancelButtonCaption.Get() +} + +// SetCancelButtonCaption sets the value of the cancelButtonCaption property. +func (o *ConfirmationInfo) SetCancelButtonCaption(v element.Element) { + o.cancelButtonCaption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConfirmationInfo) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Question"); err == nil { + o.question.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ProceedButtonCaption"); err == nil { + o.proceedButtonCaption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "CancelButtonCaption"); err == nil { + o.cancelButtonCaption.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ControlBar +// ──────────────────────────────────────────────────────── + +type ControlBar struct { + element.Base + items *property.PartList[element.Element] +} + +// ItemsItems returns the value of the items property. +func (o *ControlBar) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *ControlBar) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *ControlBar) RemoveItems(index int) { + o.items.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ControlBar) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ControlBarButton +// ──────────────────────────────────────────────────────── + +type ControlBarButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *ControlBarButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ControlBarButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ControlBarButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ControlBarButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *ControlBarButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *ControlBarButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *ControlBarButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *ControlBarButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *ControlBarButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ControlBarButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ControlBarButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ControlBarButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ControlBarButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ControlBarButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *ControlBarButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *ControlBarButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *ControlBarButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *ControlBarButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ControlBarButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// CreateObjectClientAction +// ──────────────────────────────────────────────────────── + +type CreateObjectClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + entityRef *property.Part[element.Element] + pageSettings *property.Part[element.Element] + numberOfPagesToClose *property.Primitive[int32] + numberOfPagesToClose2 *property.Primitive[string] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *CreateObjectClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *CreateObjectClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *CreateObjectClientAction) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *CreateObjectClientAction) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// PageSettings returns the value of the pageSettings property. +func (o *CreateObjectClientAction) PageSettings() element.Element { + return o.pageSettings.Get() +} + +// SetPageSettings sets the value of the pageSettings property. +func (o *CreateObjectClientAction) SetPageSettings(v element.Element) { + o.pageSettings.Set(v) +} + +// NumberOfPagesToClose returns the value of the numberOfPagesToClose property. +func (o *CreateObjectClientAction) NumberOfPagesToClose() int32 { + return o.numberOfPagesToClose.Get() +} + +// SetNumberOfPagesToClose sets the value of the numberOfPagesToClose property. +func (o *CreateObjectClientAction) SetNumberOfPagesToClose(v int32) { + o.numberOfPagesToClose.Set(v) +} + +// NumberOfPagesToClose2 returns the value of the numberOfPagesToClose2 property. +func (o *CreateObjectClientAction) NumberOfPagesToClose2() string { + return o.numberOfPagesToClose2.Get() +} + +// SetNumberOfPagesToClose2 sets the value of the numberOfPagesToClose2 property. +func (o *CreateObjectClientAction) SetNumberOfPagesToClose2(v string) { + o.numberOfPagesToClose2.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CreateObjectClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "PageSettings"); err == nil { + o.pageSettings.SetFromDecode(child) + } + o.numberOfPagesToClose.Init(raw) + o.numberOfPagesToClose2.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CustomDesignPropertyValue +// ──────────────────────────────────────────────────────── + +type CustomDesignPropertyValue struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *CustomDesignPropertyValue) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *CustomDesignPropertyValue) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomDesignPropertyValue) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataGrid +// ──────────────────────────────────────────────────────── + +type DataGrid struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + dataSource *property.Part[element.Element] + isControlBarVisible *property.Primitive[bool] + isPagingEnabled *property.Primitive[bool] + showPagingBar *property.Enum[string] + selectionMode *property.Enum[string] + selectFirst *property.Primitive[bool] + defaultButtonTrigger *property.Enum[string] + refreshTime *property.Primitive[int32] + controlBar *property.Part[element.Element] + columns *property.PartList[element.Element] + numberOfRows *property.Primitive[int32] + showEmptyRows *property.Primitive[bool] + widthUnit *property.Enum[string] + tooltipPage *property.ByNameRef[element.Element] + caption *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DataGrid) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataGrid) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *DataGrid) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataGrid) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataGrid) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataGrid) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataGrid) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataGrid) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DataGrid) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DataGrid) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataGrid) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataGrid) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *DataGrid) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *DataGrid) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// DataSource returns the value of the dataSource property. +func (o *DataGrid) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *DataGrid) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// IsControlBarVisible returns the value of the isControlBarVisible property. +func (o *DataGrid) IsControlBarVisible() bool { + return o.isControlBarVisible.Get() +} + +// SetIsControlBarVisible sets the value of the isControlBarVisible property. +func (o *DataGrid) SetIsControlBarVisible(v bool) { + o.isControlBarVisible.Set(v) +} + +// IsPagingEnabled returns the value of the isPagingEnabled property. +func (o *DataGrid) IsPagingEnabled() bool { + return o.isPagingEnabled.Get() +} + +// SetIsPagingEnabled sets the value of the isPagingEnabled property. +func (o *DataGrid) SetIsPagingEnabled(v bool) { + o.isPagingEnabled.Set(v) +} + +// ShowPagingBar returns the value of the showPagingBar property. +func (o *DataGrid) ShowPagingBar() string { + return o.showPagingBar.Get() +} + +// SetShowPagingBar sets the value of the showPagingBar property. +func (o *DataGrid) SetShowPagingBar(v string) { + o.showPagingBar.Set(v) +} + +// SelectionMode returns the value of the selectionMode property. +func (o *DataGrid) SelectionMode() string { + return o.selectionMode.Get() +} + +// SetSelectionMode sets the value of the selectionMode property. +func (o *DataGrid) SetSelectionMode(v string) { + o.selectionMode.Set(v) +} + +// SelectFirst returns the value of the selectFirst property. +func (o *DataGrid) SelectFirst() bool { + return o.selectFirst.Get() +} + +// SetSelectFirst sets the value of the selectFirst property. +func (o *DataGrid) SetSelectFirst(v bool) { + o.selectFirst.Set(v) +} + +// DefaultButtonTrigger returns the value of the defaultButtonTrigger property. +func (o *DataGrid) DefaultButtonTrigger() string { + return o.defaultButtonTrigger.Get() +} + +// SetDefaultButtonTrigger sets the value of the defaultButtonTrigger property. +func (o *DataGrid) SetDefaultButtonTrigger(v string) { + o.defaultButtonTrigger.Set(v) +} + +// RefreshTime returns the value of the refreshTime property. +func (o *DataGrid) RefreshTime() int32 { + return o.refreshTime.Get() +} + +// SetRefreshTime sets the value of the refreshTime property. +func (o *DataGrid) SetRefreshTime(v int32) { + o.refreshTime.Set(v) +} + +// ControlBar returns the value of the controlBar property. +func (o *DataGrid) ControlBar() element.Element { + return o.controlBar.Get() +} + +// SetControlBar sets the value of the controlBar property. +func (o *DataGrid) SetControlBar(v element.Element) { + o.controlBar.Set(v) +} + +// ColumnsItems returns the value of the columns property. +func (o *DataGrid) ColumnsItems() []element.Element { + return o.columns.Items() +} + +// AddColumns appends a child element to the columns list. +func (o *DataGrid) AddColumns(v element.Element) { + o.columns.Append(v) +} + +// RemoveColumns removes the element at the given index from the columns list. +func (o *DataGrid) RemoveColumns(index int) { + o.columns.Remove(index) +} + +// NumberOfRows returns the value of the numberOfRows property. +func (o *DataGrid) NumberOfRows() int32 { + return o.numberOfRows.Get() +} + +// SetNumberOfRows sets the value of the numberOfRows property. +func (o *DataGrid) SetNumberOfRows(v int32) { + o.numberOfRows.Set(v) +} + +// ShowEmptyRows returns the value of the showEmptyRows property. +func (o *DataGrid) ShowEmptyRows() bool { + return o.showEmptyRows.Get() +} + +// SetShowEmptyRows sets the value of the showEmptyRows property. +func (o *DataGrid) SetShowEmptyRows(v bool) { + o.showEmptyRows.Set(v) +} + +// WidthUnit returns the value of the widthUnit property. +func (o *DataGrid) WidthUnit() string { + return o.widthUnit.Get() +} + +// SetWidthUnit sets the value of the widthUnit property. +func (o *DataGrid) SetWidthUnit(v string) { + o.widthUnit.Set(v) +} + +// TooltipPageQualifiedName returns the value of the tooltipPage property. +func (o *DataGrid) TooltipPageQualifiedName() string { + return o.tooltipPage.QualifiedName() +} + +// SetTooltipPageQualifiedName sets the value of the tooltipPage property. +func (o *DataGrid) SetTooltipPageQualifiedName(v string) { + o.tooltipPage.SetQualifiedName(v) +} + +// Caption returns the value of the caption property. +func (o *DataGrid) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataGrid) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataGrid) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } + o.isControlBarVisible.Init(raw) + o.isPagingEnabled.Init(raw) + if val, err := raw.LookupErr("ShowPagingBar"); err == nil { + if s, ok := val.StringValueOK(); ok { o.showPagingBar.SetFromDecode(s) } + } + if val, err := raw.LookupErr("SelectionMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.selectionMode.SetFromDecode(s) } + } + o.selectFirst.Init(raw) + if val, err := raw.LookupErr("DefaultButtonTrigger"); err == nil { + if s, ok := val.StringValueOK(); ok { o.defaultButtonTrigger.SetFromDecode(s) } + } + o.refreshTime.Init(raw) + if child, err := codec.DecodeChild(raw, "ControlBar"); err == nil { + o.controlBar.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Columns"); err == nil { + for _, child := range children { + o.columns.AppendFromDecode(child) + } + } + o.numberOfRows.Init(raw) + o.showEmptyRows.Init(raw) + if val, err := raw.LookupErr("WidthUnit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.widthUnit.SetFromDecode(s) } + } + if val, err := raw.LookupErr("TooltipPage"); err == nil { + if s, ok := val.StringValueOK(); ok { o.tooltipPage.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// GridControlBarButton +// ──────────────────────────────────────────────────────── + +type GridControlBarButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *GridControlBarButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GridControlBarButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *GridControlBarButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *GridControlBarButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *GridControlBarButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *GridControlBarButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *GridControlBarButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *GridControlBarButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *GridControlBarButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *GridControlBarButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *GridControlBarButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *GridControlBarButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *GridControlBarButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *GridControlBarButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *GridControlBarButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *GridControlBarButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *GridControlBarButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *GridControlBarButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridControlBarButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// DataGridAddButton +// ──────────────────────────────────────────────────────── + +type DataGridAddButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + pageSettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DataGridAddButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataGridAddButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DataGridAddButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataGridAddButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *DataGridAddButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *DataGridAddButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *DataGridAddButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *DataGridAddButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *DataGridAddButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataGridAddButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataGridAddButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataGridAddButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataGridAddButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataGridAddButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataGridAddButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataGridAddButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *DataGridAddButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *DataGridAddButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// PageSettings returns the value of the pageSettings property. +func (o *DataGridAddButton) PageSettings() element.Element { + return o.pageSettings.Get() +} + +// SetPageSettings sets the value of the pageSettings property. +func (o *DataGridAddButton) SetPageSettings(v element.Element) { + o.pageSettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataGridAddButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "PageSettings"); err == nil { + o.pageSettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DataGridExportToCSVButton +// ──────────────────────────────────────────────────────── + +type DataGridExportToCSVButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + maxNumberOfRows *property.Primitive[int32] + decimalSeparator *property.Primitive[string] + groupSeparator *property.Primitive[string] + delimiter *property.Primitive[string] + generateExcelHint *property.Primitive[bool] + useGridDateFormat *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *DataGridExportToCSVButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataGridExportToCSVButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DataGridExportToCSVButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataGridExportToCSVButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *DataGridExportToCSVButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *DataGridExportToCSVButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *DataGridExportToCSVButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *DataGridExportToCSVButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *DataGridExportToCSVButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataGridExportToCSVButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataGridExportToCSVButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataGridExportToCSVButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataGridExportToCSVButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataGridExportToCSVButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataGridExportToCSVButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataGridExportToCSVButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *DataGridExportToCSVButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *DataGridExportToCSVButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// MaxNumberOfRows returns the value of the maxNumberOfRows property. +func (o *DataGridExportToCSVButton) MaxNumberOfRows() int32 { + return o.maxNumberOfRows.Get() +} + +// SetMaxNumberOfRows sets the value of the maxNumberOfRows property. +func (o *DataGridExportToCSVButton) SetMaxNumberOfRows(v int32) { + o.maxNumberOfRows.Set(v) +} + +// DecimalSeparator returns the value of the decimalSeparator property. +func (o *DataGridExportToCSVButton) DecimalSeparator() string { + return o.decimalSeparator.Get() +} + +// SetDecimalSeparator sets the value of the decimalSeparator property. +func (o *DataGridExportToCSVButton) SetDecimalSeparator(v string) { + o.decimalSeparator.Set(v) +} + +// GroupSeparator returns the value of the groupSeparator property. +func (o *DataGridExportToCSVButton) GroupSeparator() string { + return o.groupSeparator.Get() +} + +// SetGroupSeparator sets the value of the groupSeparator property. +func (o *DataGridExportToCSVButton) SetGroupSeparator(v string) { + o.groupSeparator.Set(v) +} + +// Delimiter returns the value of the delimiter property. +func (o *DataGridExportToCSVButton) Delimiter() string { + return o.delimiter.Get() +} + +// SetDelimiter sets the value of the delimiter property. +func (o *DataGridExportToCSVButton) SetDelimiter(v string) { + o.delimiter.Set(v) +} + +// GenerateExcelHint returns the value of the generateExcelHint property. +func (o *DataGridExportToCSVButton) GenerateExcelHint() bool { + return o.generateExcelHint.Get() +} + +// SetGenerateExcelHint sets the value of the generateExcelHint property. +func (o *DataGridExportToCSVButton) SetGenerateExcelHint(v bool) { + o.generateExcelHint.Set(v) +} + +// UseGridDateFormat returns the value of the useGridDateFormat property. +func (o *DataGridExportToCSVButton) UseGridDateFormat() bool { + return o.useGridDateFormat.Get() +} + +// SetUseGridDateFormat sets the value of the useGridDateFormat property. +func (o *DataGridExportToCSVButton) SetUseGridDateFormat(v bool) { + o.useGridDateFormat.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataGridExportToCSVButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + o.maxNumberOfRows.Init(raw) + o.decimalSeparator.Init(raw) + o.groupSeparator.Init(raw) + o.delimiter.Init(raw) + o.generateExcelHint.Init(raw) + o.useGridDateFormat.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataGridExportToExcelButton +// ──────────────────────────────────────────────────────── + +type DataGridExportToExcelButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + maxNumberOfRows *property.Primitive[int32] + useExcelDateType *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *DataGridExportToExcelButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataGridExportToExcelButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DataGridExportToExcelButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataGridExportToExcelButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *DataGridExportToExcelButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *DataGridExportToExcelButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *DataGridExportToExcelButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *DataGridExportToExcelButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *DataGridExportToExcelButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataGridExportToExcelButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataGridExportToExcelButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataGridExportToExcelButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataGridExportToExcelButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataGridExportToExcelButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataGridExportToExcelButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataGridExportToExcelButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *DataGridExportToExcelButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *DataGridExportToExcelButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// MaxNumberOfRows returns the value of the maxNumberOfRows property. +func (o *DataGridExportToExcelButton) MaxNumberOfRows() int32 { + return o.maxNumberOfRows.Get() +} + +// SetMaxNumberOfRows sets the value of the maxNumberOfRows property. +func (o *DataGridExportToExcelButton) SetMaxNumberOfRows(v int32) { + o.maxNumberOfRows.Set(v) +} + +// UseExcelDateType returns the value of the useExcelDateType property. +func (o *DataGridExportToExcelButton) UseExcelDateType() bool { + return o.useExcelDateType.Get() +} + +// SetUseExcelDateType sets the value of the useExcelDateType property. +func (o *DataGridExportToExcelButton) SetUseExcelDateType(v bool) { + o.useExcelDateType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataGridExportToExcelButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + o.maxNumberOfRows.Init(raw) + o.useExcelDateType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataGridRemoveButton +// ──────────────────────────────────────────────────────── + +type DataGridRemoveButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *DataGridRemoveButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataGridRemoveButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DataGridRemoveButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataGridRemoveButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *DataGridRemoveButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *DataGridRemoveButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *DataGridRemoveButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *DataGridRemoveButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *DataGridRemoveButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataGridRemoveButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataGridRemoveButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataGridRemoveButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataGridRemoveButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataGridRemoveButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataGridRemoveButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataGridRemoveButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *DataGridRemoveButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *DataGridRemoveButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataGridRemoveButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// DataView +// ──────────────────────────────────────────────────────── + +type DataView struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + dataSource *property.Part[element.Element] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + footerWidget *property.Part[element.Element] + footerWidgets *property.PartList[element.Element] + editable *property.Primitive[bool] + editability *property.Enum[string] + conditionalEditabilitySettings *property.Part[element.Element] + showControlBar *property.Primitive[bool] + showFooter *property.Primitive[bool] + closeOnSaveOrCancel *property.Primitive[bool] + useSchema *property.Primitive[bool] + noEntityMessage *property.Part[element.Element] + labelWidth *property.Primitive[int32] + controlBar *property.Part[element.Element] + readOnlyStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *DataView) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataView) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *DataView) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataView) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataView) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataView) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataView) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataView) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DataView) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DataView) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataView) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataView) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *DataView) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *DataView) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// DataSource returns the value of the dataSource property. +func (o *DataView) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *DataView) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// Widget returns the value of the widget property. +func (o *DataView) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *DataView) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *DataView) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *DataView) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *DataView) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// FooterWidget returns the value of the footerWidget property. +func (o *DataView) FooterWidget() element.Element { + return o.footerWidget.Get() +} + +// SetFooterWidget sets the value of the footerWidget property. +func (o *DataView) SetFooterWidget(v element.Element) { + o.footerWidget.Set(v) +} + +// FooterWidgetsItems returns the value of the footerWidgets property. +func (o *DataView) FooterWidgetsItems() []element.Element { + return o.footerWidgets.Items() +} + +// AddFooterWidgets appends a child element to the footerWidgets list. +func (o *DataView) AddFooterWidgets(v element.Element) { + o.footerWidgets.Append(v) +} + +// RemoveFooterWidgets removes the element at the given index from the footerWidgets list. +func (o *DataView) RemoveFooterWidgets(index int) { + o.footerWidgets.Remove(index) +} + +// Editable returns the value of the editable property. +func (o *DataView) Editable() bool { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *DataView) SetEditable(v bool) { + o.editable.Set(v) +} + +// Editability returns the value of the editability property. +func (o *DataView) Editability() string { + return o.editability.Get() +} + +// SetEditability sets the value of the editability property. +func (o *DataView) SetEditability(v string) { + o.editability.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *DataView) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *DataView) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// ShowControlBar returns the value of the showControlBar property. +func (o *DataView) ShowControlBar() bool { + return o.showControlBar.Get() +} + +// SetShowControlBar sets the value of the showControlBar property. +func (o *DataView) SetShowControlBar(v bool) { + o.showControlBar.Set(v) +} + +// ShowFooter returns the value of the showFooter property. +func (o *DataView) ShowFooter() bool { + return o.showFooter.Get() +} + +// SetShowFooter sets the value of the showFooter property. +func (o *DataView) SetShowFooter(v bool) { + o.showFooter.Set(v) +} + +// CloseOnSaveOrCancel returns the value of the closeOnSaveOrCancel property. +func (o *DataView) CloseOnSaveOrCancel() bool { + return o.closeOnSaveOrCancel.Get() +} + +// SetCloseOnSaveOrCancel sets the value of the closeOnSaveOrCancel property. +func (o *DataView) SetCloseOnSaveOrCancel(v bool) { + o.closeOnSaveOrCancel.Set(v) +} + +// UseSchema returns the value of the useSchema property. +func (o *DataView) UseSchema() bool { + return o.useSchema.Get() +} + +// SetUseSchema sets the value of the useSchema property. +func (o *DataView) SetUseSchema(v bool) { + o.useSchema.Set(v) +} + +// NoEntityMessage returns the value of the noEntityMessage property. +func (o *DataView) NoEntityMessage() element.Element { + return o.noEntityMessage.Get() +} + +// SetNoEntityMessage sets the value of the noEntityMessage property. +func (o *DataView) SetNoEntityMessage(v element.Element) { + o.noEntityMessage.Set(v) +} + +// LabelWidth returns the value of the labelWidth property. +func (o *DataView) LabelWidth() int32 { + return o.labelWidth.Get() +} + +// SetLabelWidth sets the value of the labelWidth property. +func (o *DataView) SetLabelWidth(v int32) { + o.labelWidth.Set(v) +} + +// ControlBar returns the value of the controlBar property. +func (o *DataView) ControlBar() element.Element { + return o.controlBar.Get() +} + +// SetControlBar sets the value of the controlBar property. +func (o *DataView) SetControlBar(v element.Element) { + o.controlBar.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *DataView) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *DataView) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataView) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "FooterWidget"); err == nil { + o.footerWidget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "FooterWidgets"); err == nil { + for _, child := range children { + o.footerWidgets.AppendFromDecode(child) + } + } + o.editable.Init(raw) + if val, err := raw.LookupErr("Editability"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editability.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + o.showControlBar.Init(raw) + o.showFooter.Init(raw) + o.closeOnSaveOrCancel.Init(raw) + o.useSchema.Init(raw) + if child, err := codec.DecodeChild(raw, "NoEntityMessage"); err == nil { + o.noEntityMessage.SetFromDecode(child) + } + o.labelWidth.Init(raw) + if child, err := codec.DecodeChild(raw, "ControlBar"); err == nil { + o.controlBar.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// DataViewControlBarButton +// ──────────────────────────────────────────────────────── + +type DataViewControlBarButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + tabIndex *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *DataViewControlBarButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataViewControlBarButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DataViewControlBarButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataViewControlBarButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *DataViewControlBarButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *DataViewControlBarButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *DataViewControlBarButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *DataViewControlBarButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *DataViewControlBarButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataViewControlBarButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataViewControlBarButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataViewControlBarButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataViewControlBarButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataViewControlBarButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataViewControlBarButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataViewControlBarButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *DataViewControlBarButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *DataViewControlBarButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DataViewControlBarButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DataViewControlBarButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataViewControlBarButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + o.tabIndex.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataViewActionButton +// ──────────────────────────────────────────────────────── + +type DataViewActionButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + tabIndex *property.Primitive[int32] + action *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DataViewActionButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataViewActionButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DataViewActionButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataViewActionButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *DataViewActionButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *DataViewActionButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *DataViewActionButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *DataViewActionButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *DataViewActionButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataViewActionButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataViewActionButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataViewActionButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataViewActionButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataViewActionButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataViewActionButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataViewActionButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *DataViewActionButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *DataViewActionButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DataViewActionButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DataViewActionButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// Action returns the value of the action property. +func (o *DataViewActionButton) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *DataViewActionButton) SetAction(v element.Element) { + o.action.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataViewActionButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DataViewCancelButton +// ──────────────────────────────────────────────────────── + +type DataViewCancelButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + tabIndex *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *DataViewCancelButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataViewCancelButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DataViewCancelButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataViewCancelButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *DataViewCancelButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *DataViewCancelButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *DataViewCancelButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *DataViewCancelButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *DataViewCancelButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataViewCancelButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataViewCancelButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataViewCancelButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataViewCancelButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataViewCancelButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataViewCancelButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataViewCancelButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *DataViewCancelButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *DataViewCancelButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DataViewCancelButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DataViewCancelButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataViewCancelButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + o.tabIndex.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataViewCloseButton +// ──────────────────────────────────────────────────────── + +type DataViewCloseButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + tabIndex *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *DataViewCloseButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataViewCloseButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DataViewCloseButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataViewCloseButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *DataViewCloseButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *DataViewCloseButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *DataViewCloseButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *DataViewCloseButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *DataViewCloseButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataViewCloseButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataViewCloseButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataViewCloseButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataViewCloseButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataViewCloseButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataViewCloseButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataViewCloseButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *DataViewCloseButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *DataViewCloseButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DataViewCloseButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DataViewCloseButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataViewCloseButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + o.tabIndex.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataViewControlBar +// ──────────────────────────────────────────────────────── + +type DataViewControlBar struct { + element.Base + items *property.PartList[element.Element] + closeButton *property.ByIdRef[element.Element] +} + +// ItemsItems returns the value of the items property. +func (o *DataViewControlBar) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *DataViewControlBar) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *DataViewControlBar) RemoveItems(index int) { + o.items.Remove(index) +} + +// CloseButtonRefID returns the value of the closeButton property. +func (o *DataViewControlBar) CloseButtonRefID() element.ID { + return o.closeButton.RefID() +} + +// SetCloseButtonID sets the value of the closeButton property. +func (o *DataViewControlBar) SetCloseButtonID(v element.ID) { + o.closeButton.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataViewControlBar) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("CloseButton"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.closeButton.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.closeButton.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// DataViewSaveButton +// ──────────────────────────────────────────────────────── + +type DataViewSaveButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + tabIndex *property.Primitive[int32] + syncAutomatically *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *DataViewSaveButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DataViewSaveButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DataViewSaveButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DataViewSaveButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *DataViewSaveButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *DataViewSaveButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *DataViewSaveButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *DataViewSaveButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *DataViewSaveButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DataViewSaveButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DataViewSaveButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DataViewSaveButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DataViewSaveButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DataViewSaveButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DataViewSaveButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DataViewSaveButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *DataViewSaveButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *DataViewSaveButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DataViewSaveButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DataViewSaveButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// SyncAutomatically returns the value of the syncAutomatically property. +func (o *DataViewSaveButton) SyncAutomatically() bool { + return o.syncAutomatically.Get() +} + +// SetSyncAutomatically sets the value of the syncAutomatically property. +func (o *DataViewSaveButton) SetSyncAutomatically(v bool) { + o.syncAutomatically.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataViewSaveButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + o.tabIndex.Init(raw) + o.syncAutomatically.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataViewSource +// ──────────────────────────────────────────────────────── + +type DataViewSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + pageParameter *property.ByNameRef[element.Element] + snippetParameter *property.ByNameRef[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *DataViewSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *DataViewSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *DataViewSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *DataViewSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *DataViewSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *DataViewSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *DataViewSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *DataViewSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// PageParameterQualifiedName returns the value of the pageParameter property. +func (o *DataViewSource) PageParameterQualifiedName() string { + return o.pageParameter.QualifiedName() +} + +// SetPageParameterQualifiedName sets the value of the pageParameter property. +func (o *DataViewSource) SetPageParameterQualifiedName(v string) { + o.pageParameter.SetQualifiedName(v) +} + +// SnippetParameterQualifiedName returns the value of the snippetParameter property. +func (o *DataViewSource) SnippetParameterQualifiedName() string { + return o.snippetParameter.QualifiedName() +} + +// SetSnippetParameterQualifiedName sets the value of the snippetParameter property. +func (o *DataViewSource) SetSnippetParameterQualifiedName(v string) { + o.snippetParameter.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataViewSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if val, err := raw.LookupErr("PageParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.pageParameter.SetFromDecode(s) } + } + if val, err := raw.LookupErr("SnippetParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.snippetParameter.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// DatabaseConstraint +// ──────────────────────────────────────────────────────── + +type DatabaseConstraint struct { + element.Base + attribute *property.ByNameRef[element.Element] + operator *property.Enum[string] + value *property.Primitive[string] +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *DatabaseConstraint) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *DatabaseConstraint) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// Operator returns the value of the operator property. +func (o *DatabaseConstraint) Operator() string { + return o.operator.Get() +} + +// SetOperator sets the value of the operator property. +func (o *DatabaseConstraint) SetOperator(v string) { + o.operator.Set(v) +} + +// Value returns the value of the value property. +func (o *DatabaseConstraint) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *DatabaseConstraint) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DatabaseConstraint) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Operator"); err == nil { + if s, ok := val.StringValueOK(); ok { o.operator.SetFromDecode(s) } + } + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SortableEntityPathSource +// ──────────────────────────────────────────────────────── + +type SortableEntityPathSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *SortableEntityPathSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *SortableEntityPathSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *SortableEntityPathSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *SortableEntityPathSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *SortableEntityPathSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *SortableEntityPathSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *SortableEntityPathSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *SortableEntityPathSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *SortableEntityPathSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *SortableEntityPathSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SortableEntityPathSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DatabaseSourceBase +// ──────────────────────────────────────────────────────── + +type DatabaseSourceBase struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] + databaseConstraints *property.PartList[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *DatabaseSourceBase) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *DatabaseSourceBase) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *DatabaseSourceBase) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *DatabaseSourceBase) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *DatabaseSourceBase) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *DatabaseSourceBase) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *DatabaseSourceBase) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *DatabaseSourceBase) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *DatabaseSourceBase) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *DatabaseSourceBase) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// DatabaseConstraintsItems returns the value of the databaseConstraints property. +func (o *DatabaseSourceBase) DatabaseConstraintsItems() []element.Element { + return o.databaseConstraints.Items() +} + +// AddDatabaseConstraints appends a child element to the databaseConstraints list. +func (o *DatabaseSourceBase) AddDatabaseConstraints(v element.Element) { + o.databaseConstraints.Append(v) +} + +// RemoveDatabaseConstraints removes the element at the given index from the databaseConstraints list. +func (o *DatabaseSourceBase) RemoveDatabaseConstraints(index int) { + o.databaseConstraints.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DatabaseSourceBase) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "DatabaseConstraints"); err == nil { + for _, child := range children { + o.databaseConstraints.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// DatePicker +// ──────────────────────────────────────────────────────── + +type DatePicker struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + required *property.Primitive[bool] + requiredMessage *property.Part[element.Element] + validation *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onEnterMicroflowSettings *property.Part[element.Element] + onLeaveMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + onEnterAction *property.Part[element.Element] + onLeaveAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + ariaRequired *property.Primitive[bool] + placeholder *property.Part[element.Element] + placeholderTemplate *property.Part[element.Element] + formattingInfo *property.Part[element.Element] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DatePicker) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DatePicker) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *DatePicker) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DatePicker) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DatePicker) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DatePicker) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DatePicker) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DatePicker) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DatePicker) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DatePicker) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DatePicker) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DatePicker) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *DatePicker) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *DatePicker) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *DatePicker) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *DatePicker) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *DatePicker) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *DatePicker) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *DatePicker) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *DatePicker) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *DatePicker) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *DatePicker) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *DatePicker) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *DatePicker) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *DatePicker) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *DatePicker) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *DatePicker) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *DatePicker) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *DatePicker) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *DatePicker) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// Required returns the value of the required property. +func (o *DatePicker) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *DatePicker) SetRequired(v bool) { + o.required.Set(v) +} + +// RequiredMessage returns the value of the requiredMessage property. +func (o *DatePicker) RequiredMessage() element.Element { + return o.requiredMessage.Get() +} + +// SetRequiredMessage sets the value of the requiredMessage property. +func (o *DatePicker) SetRequiredMessage(v element.Element) { + o.requiredMessage.Set(v) +} + +// Validation returns the value of the validation property. +func (o *DatePicker) Validation() element.Element { + return o.validation.Get() +} + +// SetValidation sets the value of the validation property. +func (o *DatePicker) SetValidation(v element.Element) { + o.validation.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *DatePicker) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *DatePicker) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnEnterMicroflowSettings returns the value of the onEnterMicroflowSettings property. +func (o *DatePicker) OnEnterMicroflowSettings() element.Element { + return o.onEnterMicroflowSettings.Get() +} + +// SetOnEnterMicroflowSettings sets the value of the onEnterMicroflowSettings property. +func (o *DatePicker) SetOnEnterMicroflowSettings(v element.Element) { + o.onEnterMicroflowSettings.Set(v) +} + +// OnLeaveMicroflowSettings returns the value of the onLeaveMicroflowSettings property. +func (o *DatePicker) OnLeaveMicroflowSettings() element.Element { + return o.onLeaveMicroflowSettings.Get() +} + +// SetOnLeaveMicroflowSettings sets the value of the onLeaveMicroflowSettings property. +func (o *DatePicker) SetOnLeaveMicroflowSettings(v element.Element) { + o.onLeaveMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *DatePicker) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *DatePicker) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// OnEnterAction returns the value of the onEnterAction property. +func (o *DatePicker) OnEnterAction() element.Element { + return o.onEnterAction.Get() +} + +// SetOnEnterAction sets the value of the onEnterAction property. +func (o *DatePicker) SetOnEnterAction(v element.Element) { + o.onEnterAction.Set(v) +} + +// OnLeaveAction returns the value of the onLeaveAction property. +func (o *DatePicker) OnLeaveAction() element.Element { + return o.onLeaveAction.Get() +} + +// SetOnLeaveAction sets the value of the onLeaveAction property. +func (o *DatePicker) SetOnLeaveAction(v element.Element) { + o.onLeaveAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *DatePicker) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *DatePicker) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// AriaRequired returns the value of the ariaRequired property. +func (o *DatePicker) AriaRequired() bool { + return o.ariaRequired.Get() +} + +// SetAriaRequired sets the value of the ariaRequired property. +func (o *DatePicker) SetAriaRequired(v bool) { + o.ariaRequired.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *DatePicker) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *DatePicker) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// PlaceholderTemplate returns the value of the placeholderTemplate property. +func (o *DatePicker) PlaceholderTemplate() element.Element { + return o.placeholderTemplate.Get() +} + +// SetPlaceholderTemplate sets the value of the placeholderTemplate property. +func (o *DatePicker) SetPlaceholderTemplate(v element.Element) { + o.placeholderTemplate.Set(v) +} + +// FormattingInfo returns the value of the formattingInfo property. +func (o *DatePicker) FormattingInfo() element.Element { + return o.formattingInfo.Get() +} + +// SetFormattingInfo sets the value of the formattingInfo property. +func (o *DatePicker) SetFormattingInfo(v element.Element) { + o.formattingInfo.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *DatePicker) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *DatePicker) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DatePicker) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + o.required.Init(raw) + if child, err := codec.DecodeChild(raw, "RequiredMessage"); err == nil { + o.requiredMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Validation"); err == nil { + o.validation.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterMicroflowSettings"); err == nil { + o.onEnterMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveMicroflowSettings"); err == nil { + o.onLeaveMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterAction"); err == nil { + o.onEnterAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveAction"); err == nil { + o.onLeaveAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.ariaRequired.Init(raw) + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "PlaceholderTemplate"); err == nil { + o.placeholderTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "FormattingInfo"); err == nil { + o.formattingInfo.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DeleteClientAction +// ──────────────────────────────────────────────────────── + +type DeleteClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + closePage *property.Primitive[bool] + sourceVariable *property.Part[element.Element] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *DeleteClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *DeleteClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// ClosePage returns the value of the closePage property. +func (o *DeleteClientAction) ClosePage() bool { + return o.closePage.Get() +} + +// SetClosePage sets the value of the closePage property. +func (o *DeleteClientAction) SetClosePage(v bool) { + o.closePage.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *DeleteClientAction) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *DeleteClientAction) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DeleteClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + o.closePage.Init(raw) + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DesignPropertyValue +// ──────────────────────────────────────────────────────── + +type DesignPropertyValue struct { + element.Base + key *property.Primitive[string] + propType *property.Enum[string] + stringValue *property.Primitive[string] + booleanValue *property.Primitive[bool] + value *property.Part[element.Element] +} + +// Key returns the value of the key property. +func (o *DesignPropertyValue) Key() string { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *DesignPropertyValue) SetKey(v string) { + o.key.Set(v) +} + +// Type returns the value of the type property. +func (o *DesignPropertyValue) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *DesignPropertyValue) SetType(v string) { + o.propType.Set(v) +} + +// StringValue returns the value of the stringValue property. +func (o *DesignPropertyValue) StringValue() string { + return o.stringValue.Get() +} + +// SetStringValue sets the value of the stringValue property. +func (o *DesignPropertyValue) SetStringValue(v string) { + o.stringValue.Set(v) +} + +// BooleanValue returns the value of the booleanValue property. +func (o *DesignPropertyValue) BooleanValue() bool { + return o.booleanValue.Get() +} + +// SetBooleanValue sets the value of the booleanValue property. +func (o *DesignPropertyValue) SetBooleanValue(v bool) { + o.booleanValue.Set(v) +} + +// Value returns the value of the value property. +func (o *DesignPropertyValue) Value() element.Element { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *DesignPropertyValue) SetValue(v element.Element) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DesignPropertyValue) InitFromRaw(raw bson.Raw) { + o.key.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.stringValue.Init(raw) + o.booleanValue.Init(raw) + if child, err := codec.DecodeChild(raw, "Value"); err == nil { + o.value.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DivContainer +// ──────────────────────────────────────────────────────── + +type DivContainer struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + renderMode *property.Enum[string] + onClickAction *property.Part[element.Element] + screenReaderHidden *property.Primitive[bool] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DivContainer) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DivContainer) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *DivContainer) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DivContainer) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DivContainer) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DivContainer) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DivContainer) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DivContainer) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DivContainer) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DivContainer) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DivContainer) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DivContainer) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *DivContainer) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *DivContainer) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Widget returns the value of the widget property. +func (o *DivContainer) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *DivContainer) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *DivContainer) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *DivContainer) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *DivContainer) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// RenderMode returns the value of the renderMode property. +func (o *DivContainer) RenderMode() string { + return o.renderMode.Get() +} + +// SetRenderMode sets the value of the renderMode property. +func (o *DivContainer) SetRenderMode(v string) { + o.renderMode.Set(v) +} + +// OnClickAction returns the value of the onClickAction property. +func (o *DivContainer) OnClickAction() element.Element { + return o.onClickAction.Get() +} + +// SetOnClickAction sets the value of the onClickAction property. +func (o *DivContainer) SetOnClickAction(v element.Element) { + o.onClickAction.Set(v) +} + +// ScreenReaderHidden returns the value of the screenReaderHidden property. +func (o *DivContainer) ScreenReaderHidden() bool { + return o.screenReaderHidden.Get() +} + +// SetScreenReaderHidden sets the value of the screenReaderHidden property. +func (o *DivContainer) SetScreenReaderHidden(v bool) { + o.screenReaderHidden.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *DivContainer) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *DivContainer) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DivContainer) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("RenderMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderMode.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "OnClickAction"); err == nil { + o.onClickAction.SetFromDecode(child) + } + o.screenReaderHidden.Init(raw) + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DropDown +// ──────────────────────────────────────────────────────── + +type DropDown struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + required *property.Primitive[bool] + requiredMessage *property.Part[element.Element] + validation *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onEnterMicroflowSettings *property.Part[element.Element] + onLeaveMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + onEnterAction *property.Part[element.Element] + onLeaveAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + ariaRequired *property.Primitive[bool] + emptyOptionCaption *property.Part[element.Element] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DropDown) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DropDown) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *DropDown) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DropDown) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DropDown) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DropDown) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DropDown) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DropDown) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DropDown) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DropDown) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DropDown) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DropDown) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *DropDown) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *DropDown) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *DropDown) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *DropDown) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *DropDown) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *DropDown) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *DropDown) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *DropDown) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *DropDown) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *DropDown) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *DropDown) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *DropDown) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *DropDown) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *DropDown) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *DropDown) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *DropDown) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *DropDown) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *DropDown) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// Required returns the value of the required property. +func (o *DropDown) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *DropDown) SetRequired(v bool) { + o.required.Set(v) +} + +// RequiredMessage returns the value of the requiredMessage property. +func (o *DropDown) RequiredMessage() element.Element { + return o.requiredMessage.Get() +} + +// SetRequiredMessage sets the value of the requiredMessage property. +func (o *DropDown) SetRequiredMessage(v element.Element) { + o.requiredMessage.Set(v) +} + +// Validation returns the value of the validation property. +func (o *DropDown) Validation() element.Element { + return o.validation.Get() +} + +// SetValidation sets the value of the validation property. +func (o *DropDown) SetValidation(v element.Element) { + o.validation.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *DropDown) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *DropDown) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnEnterMicroflowSettings returns the value of the onEnterMicroflowSettings property. +func (o *DropDown) OnEnterMicroflowSettings() element.Element { + return o.onEnterMicroflowSettings.Get() +} + +// SetOnEnterMicroflowSettings sets the value of the onEnterMicroflowSettings property. +func (o *DropDown) SetOnEnterMicroflowSettings(v element.Element) { + o.onEnterMicroflowSettings.Set(v) +} + +// OnLeaveMicroflowSettings returns the value of the onLeaveMicroflowSettings property. +func (o *DropDown) OnLeaveMicroflowSettings() element.Element { + return o.onLeaveMicroflowSettings.Get() +} + +// SetOnLeaveMicroflowSettings sets the value of the onLeaveMicroflowSettings property. +func (o *DropDown) SetOnLeaveMicroflowSettings(v element.Element) { + o.onLeaveMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *DropDown) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *DropDown) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// OnEnterAction returns the value of the onEnterAction property. +func (o *DropDown) OnEnterAction() element.Element { + return o.onEnterAction.Get() +} + +// SetOnEnterAction sets the value of the onEnterAction property. +func (o *DropDown) SetOnEnterAction(v element.Element) { + o.onEnterAction.Set(v) +} + +// OnLeaveAction returns the value of the onLeaveAction property. +func (o *DropDown) OnLeaveAction() element.Element { + return o.onLeaveAction.Get() +} + +// SetOnLeaveAction sets the value of the onLeaveAction property. +func (o *DropDown) SetOnLeaveAction(v element.Element) { + o.onLeaveAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *DropDown) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *DropDown) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// AriaRequired returns the value of the ariaRequired property. +func (o *DropDown) AriaRequired() bool { + return o.ariaRequired.Get() +} + +// SetAriaRequired sets the value of the ariaRequired property. +func (o *DropDown) SetAriaRequired(v bool) { + o.ariaRequired.Set(v) +} + +// EmptyOptionCaption returns the value of the emptyOptionCaption property. +func (o *DropDown) EmptyOptionCaption() element.Element { + return o.emptyOptionCaption.Get() +} + +// SetEmptyOptionCaption sets the value of the emptyOptionCaption property. +func (o *DropDown) SetEmptyOptionCaption(v element.Element) { + o.emptyOptionCaption.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *DropDown) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *DropDown) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DropDown) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + o.required.Init(raw) + if child, err := codec.DecodeChild(raw, "RequiredMessage"); err == nil { + o.requiredMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Validation"); err == nil { + o.validation.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterMicroflowSettings"); err == nil { + o.onEnterMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveMicroflowSettings"); err == nil { + o.onLeaveMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterAction"); err == nil { + o.onEnterAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveAction"); err == nil { + o.onLeaveAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.ariaRequired.Init(raw) + if child, err := codec.DecodeChild(raw, "EmptyOptionCaption"); err == nil { + o.emptyOptionCaption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DropDownButton +// ──────────────────────────────────────────────────────── + +type DropDownButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] + items *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *DropDownButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DropDownButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *DropDownButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DropDownButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DropDownButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DropDownButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DropDownButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DropDownButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DropDownButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DropDownButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DropDownButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DropDownButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *DropDownButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *DropDownButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DropDownButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DropDownButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *DropDownButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *DropDownButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *DropDownButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *DropDownButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *DropDownButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *DropDownButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *DropDownButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *DropDownButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// ItemsItems returns the value of the items property. +func (o *DropDownButton) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *DropDownButton) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *DropDownButton) RemoveItems(index int) { + o.items.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DropDownButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// DropDownButtonItem +// ──────────────────────────────────────────────────────── + +type DropDownButtonItem struct { + element.Base + action *property.Part[element.Element] + caption *property.Part[element.Element] + image *property.ByNameRef[element.Element] +} + +// Action returns the value of the action property. +func (o *DropDownButtonItem) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *DropDownButtonItem) SetAction(v element.Element) { + o.action.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DropDownButtonItem) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DropDownButtonItem) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// ImageQualifiedName returns the value of the image property. +func (o *DropDownButtonItem) ImageQualifiedName() string { + return o.image.QualifiedName() +} + +// SetImageQualifiedName sets the value of the image property. +func (o *DropDownButtonItem) SetImageQualifiedName(v string) { + o.image.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DropDownButtonItem) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if val, err := raw.LookupErr("Image"); err == nil { + if s, ok := val.StringValueOK(); ok { o.image.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// DropDownSearchField +// ──────────────────────────────────────────────────────── + +type DropDownSearchField struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + placeholder *property.Part[element.Element] + customDateFormat *property.Primitive[string] + propType *property.Enum[string] + defaultValue *property.Primitive[string] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + operator *property.Enum[string] + sortBar *property.Part[element.Element] + xPathConstraint *property.Primitive[string] + allowMultipleSelect *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *DropDownSearchField) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DropDownSearchField) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *DropDownSearchField) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *DropDownSearchField) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *DropDownSearchField) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *DropDownSearchField) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// CustomDateFormat returns the value of the customDateFormat property. +func (o *DropDownSearchField) CustomDateFormat() string { + return o.customDateFormat.Get() +} + +// SetCustomDateFormat sets the value of the customDateFormat property. +func (o *DropDownSearchField) SetCustomDateFormat(v string) { + o.customDateFormat.Set(v) +} + +// Type returns the value of the type property. +func (o *DropDownSearchField) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *DropDownSearchField) SetType(v string) { + o.propType.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *DropDownSearchField) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *DropDownSearchField) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *DropDownSearchField) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *DropDownSearchField) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *DropDownSearchField) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *DropDownSearchField) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// Operator returns the value of the operator property. +func (o *DropDownSearchField) Operator() string { + return o.operator.Get() +} + +// SetOperator sets the value of the operator property. +func (o *DropDownSearchField) SetOperator(v string) { + o.operator.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *DropDownSearchField) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *DropDownSearchField) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *DropDownSearchField) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *DropDownSearchField) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// AllowMultipleSelect returns the value of the allowMultipleSelect property. +func (o *DropDownSearchField) AllowMultipleSelect() bool { + return o.allowMultipleSelect.Get() +} + +// SetAllowMultipleSelect sets the value of the allowMultipleSelect property. +func (o *DropDownSearchField) SetAllowMultipleSelect(v bool) { + o.allowMultipleSelect.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DropDownSearchField) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } + o.customDateFormat.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.defaultValue.Init(raw) + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("Operator"); err == nil { + if s, ok := val.StringValueOK(); ok { o.operator.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + o.xPathConstraint.Init(raw) + o.allowMultipleSelect.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DynamicImageViewer +// ──────────────────────────────────────────────────────── + +type DynamicImageViewer struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + dataSource *property.Part[element.Element] + defaultImage *property.ByNameRef[element.Element] + widthUnit *property.Enum[string] + heightUnit *property.Enum[string] + width *property.Primitive[int32] + height *property.Primitive[int32] + responsive *property.Primitive[bool] + showAsThumbnail *property.Primitive[bool] + onClickBehavior *property.Part[element.Element] + clickAction *property.Part[element.Element] + onClickEnlarge *property.Primitive[bool] + alternativeText *property.Part[element.Element] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DynamicImageViewer) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DynamicImageViewer) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *DynamicImageViewer) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DynamicImageViewer) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DynamicImageViewer) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DynamicImageViewer) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DynamicImageViewer) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DynamicImageViewer) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DynamicImageViewer) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DynamicImageViewer) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DynamicImageViewer) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DynamicImageViewer) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *DynamicImageViewer) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *DynamicImageViewer) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// DataSource returns the value of the dataSource property. +func (o *DynamicImageViewer) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *DynamicImageViewer) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// DefaultImageQualifiedName returns the value of the defaultImage property. +func (o *DynamicImageViewer) DefaultImageQualifiedName() string { + return o.defaultImage.QualifiedName() +} + +// SetDefaultImageQualifiedName sets the value of the defaultImage property. +func (o *DynamicImageViewer) SetDefaultImageQualifiedName(v string) { + o.defaultImage.SetQualifiedName(v) +} + +// WidthUnit returns the value of the widthUnit property. +func (o *DynamicImageViewer) WidthUnit() string { + return o.widthUnit.Get() +} + +// SetWidthUnit sets the value of the widthUnit property. +func (o *DynamicImageViewer) SetWidthUnit(v string) { + o.widthUnit.Set(v) +} + +// HeightUnit returns the value of the heightUnit property. +func (o *DynamicImageViewer) HeightUnit() string { + return o.heightUnit.Get() +} + +// SetHeightUnit sets the value of the heightUnit property. +func (o *DynamicImageViewer) SetHeightUnit(v string) { + o.heightUnit.Set(v) +} + +// Width returns the value of the width property. +func (o *DynamicImageViewer) Width() int32 { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *DynamicImageViewer) SetWidth(v int32) { + o.width.Set(v) +} + +// Height returns the value of the height property. +func (o *DynamicImageViewer) Height() int32 { + return o.height.Get() +} + +// SetHeight sets the value of the height property. +func (o *DynamicImageViewer) SetHeight(v int32) { + o.height.Set(v) +} + +// Responsive returns the value of the responsive property. +func (o *DynamicImageViewer) Responsive() bool { + return o.responsive.Get() +} + +// SetResponsive sets the value of the responsive property. +func (o *DynamicImageViewer) SetResponsive(v bool) { + o.responsive.Set(v) +} + +// ShowAsThumbnail returns the value of the showAsThumbnail property. +func (o *DynamicImageViewer) ShowAsThumbnail() bool { + return o.showAsThumbnail.Get() +} + +// SetShowAsThumbnail sets the value of the showAsThumbnail property. +func (o *DynamicImageViewer) SetShowAsThumbnail(v bool) { + o.showAsThumbnail.Set(v) +} + +// OnClickBehavior returns the value of the onClickBehavior property. +func (o *DynamicImageViewer) OnClickBehavior() element.Element { + return o.onClickBehavior.Get() +} + +// SetOnClickBehavior sets the value of the onClickBehavior property. +func (o *DynamicImageViewer) SetOnClickBehavior(v element.Element) { + o.onClickBehavior.Set(v) +} + +// ClickAction returns the value of the clickAction property. +func (o *DynamicImageViewer) ClickAction() element.Element { + return o.clickAction.Get() +} + +// SetClickAction sets the value of the clickAction property. +func (o *DynamicImageViewer) SetClickAction(v element.Element) { + o.clickAction.Set(v) +} + +// OnClickEnlarge returns the value of the onClickEnlarge property. +func (o *DynamicImageViewer) OnClickEnlarge() bool { + return o.onClickEnlarge.Get() +} + +// SetOnClickEnlarge sets the value of the onClickEnlarge property. +func (o *DynamicImageViewer) SetOnClickEnlarge(v bool) { + o.onClickEnlarge.Set(v) +} + +// AlternativeText returns the value of the alternativeText property. +func (o *DynamicImageViewer) AlternativeText() element.Element { + return o.alternativeText.Get() +} + +// SetAlternativeText sets the value of the alternativeText property. +func (o *DynamicImageViewer) SetAlternativeText(v element.Element) { + o.alternativeText.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *DynamicImageViewer) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *DynamicImageViewer) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DynamicImageViewer) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } + if val, err := raw.LookupErr("DefaultImage"); err == nil { + if s, ok := val.StringValueOK(); ok { o.defaultImage.SetFromDecode(s) } + } + if val, err := raw.LookupErr("WidthUnit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.widthUnit.SetFromDecode(s) } + } + if val, err := raw.LookupErr("HeightUnit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.heightUnit.SetFromDecode(s) } + } + o.width.Init(raw) + o.height.Init(raw) + o.responsive.Init(raw) + o.showAsThumbnail.Init(raw) + if child, err := codec.DecodeChild(raw, "OnClickBehavior"); err == nil { + o.onClickBehavior.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ClickAction"); err == nil { + o.clickAction.SetFromDecode(child) + } + o.onClickEnlarge.Init(raw) + if child, err := codec.DecodeChild(raw, "AlternativeText"); err == nil { + o.alternativeText.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// DynamicText +// ──────────────────────────────────────────────────────── + +type DynamicText struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + content *property.Part[element.Element] + renderMode *property.Enum[string] + nativeTextStyle *property.Enum[string] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *DynamicText) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *DynamicText) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *DynamicText) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *DynamicText) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *DynamicText) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *DynamicText) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *DynamicText) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *DynamicText) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *DynamicText) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *DynamicText) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *DynamicText) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *DynamicText) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *DynamicText) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *DynamicText) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Content returns the value of the content property. +func (o *DynamicText) Content() element.Element { + return o.content.Get() +} + +// SetContent sets the value of the content property. +func (o *DynamicText) SetContent(v element.Element) { + o.content.Set(v) +} + +// RenderMode returns the value of the renderMode property. +func (o *DynamicText) RenderMode() string { + return o.renderMode.Get() +} + +// SetRenderMode sets the value of the renderMode property. +func (o *DynamicText) SetRenderMode(v string) { + o.renderMode.Set(v) +} + +// NativeTextStyle returns the value of the nativeTextStyle property. +func (o *DynamicText) NativeTextStyle() string { + return o.nativeTextStyle.Get() +} + +// SetNativeTextStyle sets the value of the nativeTextStyle property. +func (o *DynamicText) SetNativeTextStyle(v string) { + o.nativeTextStyle.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *DynamicText) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *DynamicText) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DynamicText) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Content"); err == nil { + o.content.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderMode.SetFromDecode(s) } + } + if val, err := raw.LookupErr("NativeTextStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.nativeTextStyle.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TemplateType +// ──────────────────────────────────────────────────────── + +type TemplateType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TemplateType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EditPageTemplateType +// ──────────────────────────────────────────────────────── + +type EditPageTemplateType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EditPageTemplateType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// FileManager +// ──────────────────────────────────────────────────────── + +type FileManager struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + allowedExtensions *property.Primitive[string] + propType *property.Enum[string] + maxFileSize *property.Primitive[int32] + showFileInBrowser *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *FileManager) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *FileManager) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *FileManager) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *FileManager) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *FileManager) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *FileManager) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *FileManager) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *FileManager) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *FileManager) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *FileManager) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *FileManager) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *FileManager) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *FileManager) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *FileManager) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *FileManager) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *FileManager) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *FileManager) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *FileManager) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *FileManager) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *FileManager) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *FileManager) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *FileManager) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *FileManager) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *FileManager) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AllowedExtensions returns the value of the allowedExtensions property. +func (o *FileManager) AllowedExtensions() string { + return o.allowedExtensions.Get() +} + +// SetAllowedExtensions sets the value of the allowedExtensions property. +func (o *FileManager) SetAllowedExtensions(v string) { + o.allowedExtensions.Set(v) +} + +// Type returns the value of the type property. +func (o *FileManager) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *FileManager) SetType(v string) { + o.propType.Set(v) +} + +// MaxFileSize returns the value of the maxFileSize property. +func (o *FileManager) MaxFileSize() int32 { + return o.maxFileSize.Get() +} + +// SetMaxFileSize sets the value of the maxFileSize property. +func (o *FileManager) SetMaxFileSize(v int32) { + o.maxFileSize.Set(v) +} + +// ShowFileInBrowser returns the value of the showFileInBrowser property. +func (o *FileManager) ShowFileInBrowser() bool { + return o.showFileInBrowser.Get() +} + +// SetShowFileInBrowser sets the value of the showFileInBrowser property. +func (o *FileManager) SetShowFileInBrowser(v bool) { + o.showFileInBrowser.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FileManager) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.allowedExtensions.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.maxFileSize.Init(raw) + o.showFileInBrowser.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// FormattingInfo +// ──────────────────────────────────────────────────────── + +type FormattingInfo struct { + element.Base + decimalPrecision *property.Primitive[int32] + groupDigits *property.Primitive[bool] + enumFormat *property.Enum[string] + dateFormat *property.Enum[string] + customDateFormat *property.Primitive[string] +} + +// DecimalPrecision returns the value of the decimalPrecision property. +func (o *FormattingInfo) DecimalPrecision() int32 { + return o.decimalPrecision.Get() +} + +// SetDecimalPrecision sets the value of the decimalPrecision property. +func (o *FormattingInfo) SetDecimalPrecision(v int32) { + o.decimalPrecision.Set(v) +} + +// GroupDigits returns the value of the groupDigits property. +func (o *FormattingInfo) GroupDigits() bool { + return o.groupDigits.Get() +} + +// SetGroupDigits sets the value of the groupDigits property. +func (o *FormattingInfo) SetGroupDigits(v bool) { + o.groupDigits.Set(v) +} + +// EnumFormat returns the value of the enumFormat property. +func (o *FormattingInfo) EnumFormat() string { + return o.enumFormat.Get() +} + +// SetEnumFormat sets the value of the enumFormat property. +func (o *FormattingInfo) SetEnumFormat(v string) { + o.enumFormat.Set(v) +} + +// DateFormat returns the value of the dateFormat property. +func (o *FormattingInfo) DateFormat() string { + return o.dateFormat.Get() +} + +// SetDateFormat sets the value of the dateFormat property. +func (o *FormattingInfo) SetDateFormat(v string) { + o.dateFormat.Set(v) +} + +// CustomDateFormat returns the value of the customDateFormat property. +func (o *FormattingInfo) CustomDateFormat() string { + return o.customDateFormat.Get() +} + +// SetCustomDateFormat sets the value of the customDateFormat property. +func (o *FormattingInfo) SetCustomDateFormat(v string) { + o.customDateFormat.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FormattingInfo) InitFromRaw(raw bson.Raw) { + o.decimalPrecision.Init(raw) + o.groupDigits.Init(raw) + if val, err := raw.LookupErr("EnumFormat"); err == nil { + if s, ok := val.StringValueOK(); ok { o.enumFormat.SetFromDecode(s) } + } + if val, err := raw.LookupErr("DateFormat"); err == nil { + if s, ok := val.StringValueOK(); ok { o.dateFormat.SetFromDecode(s) } + } + o.customDateFormat.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Icon +// ──────────────────────────────────────────────────────── + +type Icon struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Icon) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// GlyphIcon +// ──────────────────────────────────────────────────────── + +type GlyphIcon struct { + element.Base + code *property.Primitive[int32] +} + +// Code returns the value of the code property. +func (o *GlyphIcon) Code() int32 { + return o.code.Get() +} + +// SetCode sets the value of the code property. +func (o *GlyphIcon) SetCode(v int32) { + o.code.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GlyphIcon) InitFromRaw(raw bson.Raw) { + o.code.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// GridActionButton +// ──────────────────────────────────────────────────────── + +type GridActionButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + action *property.Part[element.Element] + maintainSelectionAfterMicroflow *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *GridActionButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GridActionButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *GridActionButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *GridActionButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *GridActionButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *GridActionButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *GridActionButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *GridActionButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *GridActionButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *GridActionButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *GridActionButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *GridActionButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *GridActionButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *GridActionButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *GridActionButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *GridActionButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *GridActionButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *GridActionButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// Action returns the value of the action property. +func (o *GridActionButton) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *GridActionButton) SetAction(v element.Element) { + o.action.Set(v) +} + +// MaintainSelectionAfterMicroflow returns the value of the maintainSelectionAfterMicroflow property. +func (o *GridActionButton) MaintainSelectionAfterMicroflow() bool { + return o.maintainSelectionAfterMicroflow.Get() +} + +// SetMaintainSelectionAfterMicroflow sets the value of the maintainSelectionAfterMicroflow property. +func (o *GridActionButton) SetMaintainSelectionAfterMicroflow(v bool) { + o.maintainSelectionAfterMicroflow.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridActionButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } + o.maintainSelectionAfterMicroflow.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// GridBaseSource +// ──────────────────────────────────────────────────────── + +type GridBaseSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] + searchBar *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *GridBaseSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *GridBaseSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *GridBaseSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *GridBaseSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *GridBaseSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *GridBaseSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *GridBaseSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *GridBaseSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *GridBaseSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *GridBaseSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// SearchBar returns the value of the searchBar property. +func (o *GridBaseSource) SearchBar() element.Element { + return o.searchBar.Get() +} + +// SetSearchBar sets the value of the searchBar property. +func (o *GridBaseSource) SetSearchBar(v element.Element) { + o.searchBar.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridBaseSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SearchBar"); err == nil { + o.searchBar.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// GridColumn +// ──────────────────────────────────────────────────────── + +type GridColumn struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + formattingInfo *property.Part[element.Element] + showTooltip *property.Primitive[bool] + aggregateCaption *property.Part[element.Element] + aggregateFunction *property.Enum[string] + editable *property.Primitive[bool] + width *property.Primitive[int32] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *GridColumn) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GridColumn) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *GridColumn) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *GridColumn) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *GridColumn) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *GridColumn) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *GridColumn) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *GridColumn) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// FormattingInfo returns the value of the formattingInfo property. +func (o *GridColumn) FormattingInfo() element.Element { + return o.formattingInfo.Get() +} + +// SetFormattingInfo sets the value of the formattingInfo property. +func (o *GridColumn) SetFormattingInfo(v element.Element) { + o.formattingInfo.Set(v) +} + +// ShowTooltip returns the value of the showTooltip property. +func (o *GridColumn) ShowTooltip() bool { + return o.showTooltip.Get() +} + +// SetShowTooltip sets the value of the showTooltip property. +func (o *GridColumn) SetShowTooltip(v bool) { + o.showTooltip.Set(v) +} + +// AggregateCaption returns the value of the aggregateCaption property. +func (o *GridColumn) AggregateCaption() element.Element { + return o.aggregateCaption.Get() +} + +// SetAggregateCaption sets the value of the aggregateCaption property. +func (o *GridColumn) SetAggregateCaption(v element.Element) { + o.aggregateCaption.Set(v) +} + +// AggregateFunction returns the value of the aggregateFunction property. +func (o *GridColumn) AggregateFunction() string { + return o.aggregateFunction.Get() +} + +// SetAggregateFunction sets the value of the aggregateFunction property. +func (o *GridColumn) SetAggregateFunction(v string) { + o.aggregateFunction.Set(v) +} + +// Editable returns the value of the editable property. +func (o *GridColumn) Editable() bool { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *GridColumn) SetEditable(v bool) { + o.editable.Set(v) +} + +// Width returns the value of the width property. +func (o *GridColumn) Width() int32 { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *GridColumn) SetWidth(v int32) { + o.width.Set(v) +} + +// Class returns the value of the class property. +func (o *GridColumn) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *GridColumn) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *GridColumn) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *GridColumn) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *GridColumn) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *GridColumn) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridColumn) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "FormattingInfo"); err == nil { + o.formattingInfo.SetFromDecode(child) + } + o.showTooltip.Init(raw) + if child, err := codec.DecodeChild(raw, "AggregateCaption"); err == nil { + o.aggregateCaption.SetFromDecode(child) + } + if val, err := raw.LookupErr("AggregateFunction"); err == nil { + if s, ok := val.StringValueOK(); ok { o.aggregateFunction.SetFromDecode(s) } + } + o.editable.Init(raw) + o.width.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// GridControlBar +// ──────────────────────────────────────────────────────── + +type GridControlBar struct { + element.Base + items *property.PartList[element.Element] + searchButton *property.Part[element.Element] + defaultButton *property.ByIdRef[element.Element] +} + +// ItemsItems returns the value of the items property. +func (o *GridControlBar) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *GridControlBar) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *GridControlBar) RemoveItems(index int) { + o.items.Remove(index) +} + +// SearchButton returns the value of the searchButton property. +func (o *GridControlBar) SearchButton() element.Element { + return o.searchButton.Get() +} + +// SetSearchButton sets the value of the searchButton property. +func (o *GridControlBar) SetSearchButton(v element.Element) { + o.searchButton.Set(v) +} + +// DefaultButtonRefID returns the value of the defaultButton property. +func (o *GridControlBar) DefaultButtonRefID() element.ID { + return o.defaultButton.RefID() +} + +// SetDefaultButtonID sets the value of the defaultButton property. +func (o *GridControlBar) SetDefaultButtonID(v element.ID) { + o.defaultButton.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridControlBar) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "SearchButton"); err == nil { + o.searchButton.SetFromDecode(child) + } + if val, err := raw.LookupErr("DefaultButtonPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.defaultButton.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.defaultButton.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// GridDatabaseSource +// ──────────────────────────────────────────────────────── + +type GridDatabaseSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] + databaseConstraints *property.PartList[element.Element] + searchBar *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *GridDatabaseSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *GridDatabaseSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *GridDatabaseSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *GridDatabaseSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *GridDatabaseSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *GridDatabaseSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *GridDatabaseSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *GridDatabaseSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *GridDatabaseSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *GridDatabaseSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// DatabaseConstraintsItems returns the value of the databaseConstraints property. +func (o *GridDatabaseSource) DatabaseConstraintsItems() []element.Element { + return o.databaseConstraints.Items() +} + +// AddDatabaseConstraints appends a child element to the databaseConstraints list. +func (o *GridDatabaseSource) AddDatabaseConstraints(v element.Element) { + o.databaseConstraints.Append(v) +} + +// RemoveDatabaseConstraints removes the element at the given index from the databaseConstraints list. +func (o *GridDatabaseSource) RemoveDatabaseConstraints(index int) { + o.databaseConstraints.Remove(index) +} + +// SearchBar returns the value of the searchBar property. +func (o *GridDatabaseSource) SearchBar() element.Element { + return o.searchBar.Get() +} + +// SetSearchBar sets the value of the searchBar property. +func (o *GridDatabaseSource) SetSearchBar(v element.Element) { + o.searchBar.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridDatabaseSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "DatabaseConstraints"); err == nil { + for _, child := range children { + o.databaseConstraints.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "SearchBar"); err == nil { + o.searchBar.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// GridDeleteButton +// ──────────────────────────────────────────────────────── + +type GridDeleteButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *GridDeleteButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GridDeleteButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *GridDeleteButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *GridDeleteButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *GridDeleteButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *GridDeleteButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *GridDeleteButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *GridDeleteButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *GridDeleteButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *GridDeleteButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *GridDeleteButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *GridDeleteButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *GridDeleteButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *GridDeleteButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *GridDeleteButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *GridDeleteButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *GridDeleteButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *GridDeleteButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridDeleteButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// GridDeselectAllButton +// ──────────────────────────────────────────────────────── + +type GridDeselectAllButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *GridDeselectAllButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GridDeselectAllButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *GridDeselectAllButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *GridDeselectAllButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *GridDeselectAllButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *GridDeselectAllButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *GridDeselectAllButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *GridDeselectAllButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *GridDeselectAllButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *GridDeselectAllButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *GridDeselectAllButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *GridDeselectAllButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *GridDeselectAllButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *GridDeselectAllButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *GridDeselectAllButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *GridDeselectAllButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *GridDeselectAllButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *GridDeselectAllButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridDeselectAllButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// GridEditButton +// ──────────────────────────────────────────────────────── + +type GridEditButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + pageSettings *property.Part[element.Element] + pagesForSpecializations *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *GridEditButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GridEditButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *GridEditButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *GridEditButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *GridEditButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *GridEditButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *GridEditButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *GridEditButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *GridEditButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *GridEditButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *GridEditButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *GridEditButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *GridEditButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *GridEditButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *GridEditButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *GridEditButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *GridEditButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *GridEditButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// PageSettings returns the value of the pageSettings property. +func (o *GridEditButton) PageSettings() element.Element { + return o.pageSettings.Get() +} + +// SetPageSettings sets the value of the pageSettings property. +func (o *GridEditButton) SetPageSettings(v element.Element) { + o.pageSettings.Set(v) +} + +// PagesForSpecializationsItems returns the value of the pagesForSpecializations property. +func (o *GridEditButton) PagesForSpecializationsItems() []element.Element { + return o.pagesForSpecializations.Items() +} + +// AddPagesForSpecializations appends a child element to the pagesForSpecializations list. +func (o *GridEditButton) AddPagesForSpecializations(v element.Element) { + o.pagesForSpecializations.Append(v) +} + +// RemovePagesForSpecializations removes the element at the given index from the pagesForSpecializations list. +func (o *GridEditButton) RemovePagesForSpecializations(index int) { + o.pagesForSpecializations.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridEditButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "PageSettings"); err == nil { + o.pageSettings.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "PagesForSpecializations"); err == nil { + for _, child := range children { + o.pagesForSpecializations.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// GridNewButton +// ──────────────────────────────────────────────────────── + +type GridNewButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + entity *property.ByNameRef[element.Element] + editLocation *property.Enum[string] + pageSettings *property.Part[element.Element] + isPersistent *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *GridNewButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GridNewButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *GridNewButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *GridNewButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *GridNewButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *GridNewButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *GridNewButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *GridNewButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *GridNewButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *GridNewButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *GridNewButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *GridNewButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *GridNewButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *GridNewButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *GridNewButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *GridNewButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *GridNewButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *GridNewButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *GridNewButton) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *GridNewButton) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// EditLocation returns the value of the editLocation property. +func (o *GridNewButton) EditLocation() string { + return o.editLocation.Get() +} + +// SetEditLocation sets the value of the editLocation property. +func (o *GridNewButton) SetEditLocation(v string) { + o.editLocation.Set(v) +} + +// PageSettings returns the value of the pageSettings property. +func (o *GridNewButton) PageSettings() element.Element { + return o.pageSettings.Get() +} + +// SetPageSettings sets the value of the pageSettings property. +func (o *GridNewButton) SetPageSettings(v element.Element) { + o.pageSettings.Set(v) +} + +// IsPersistent returns the value of the isPersistent property. +func (o *GridNewButton) IsPersistent() bool { + return o.isPersistent.Get() +} + +// SetIsPersistent sets the value of the isPersistent property. +func (o *GridNewButton) SetIsPersistent(v bool) { + o.isPersistent.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridNewButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } + if val, err := raw.LookupErr("EditLocation"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editLocation.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "PageSettings"); err == nil { + o.pageSettings.SetFromDecode(child) + } + o.isPersistent.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// GridSearchButton +// ──────────────────────────────────────────────────────── + +type GridSearchButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *GridSearchButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GridSearchButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *GridSearchButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *GridSearchButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *GridSearchButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *GridSearchButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *GridSearchButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *GridSearchButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *GridSearchButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *GridSearchButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *GridSearchButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *GridSearchButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *GridSearchButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *GridSearchButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *GridSearchButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *GridSearchButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *GridSearchButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *GridSearchButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridSearchButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// GridSelectAllButton +// ──────────────────────────────────────────────────────── + +type GridSelectAllButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] + selectionType *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *GridSelectAllButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GridSelectAllButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *GridSelectAllButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *GridSelectAllButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *GridSelectAllButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *GridSelectAllButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *GridSelectAllButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *GridSelectAllButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *GridSelectAllButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *GridSelectAllButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *GridSelectAllButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *GridSelectAllButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *GridSelectAllButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *GridSelectAllButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *GridSelectAllButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *GridSelectAllButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *GridSelectAllButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *GridSelectAllButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// SelectionType returns the value of the selectionType property. +func (o *GridSelectAllButton) SelectionType() string { + return o.selectionType.Get() +} + +// SetSelectionType sets the value of the selectionType property. +func (o *GridSelectAllButton) SetSelectionType(v string) { + o.selectionType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridSelectAllButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + if val, err := raw.LookupErr("SelectionType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.selectionType.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// GridSortBar +// ──────────────────────────────────────────────────────── + +type GridSortBar struct { + element.Base + sortItems *property.PartList[element.Element] +} + +// SortItemsItems returns the value of the sortItems property. +func (o *GridSortBar) SortItemsItems() []element.Element { + return o.sortItems.Items() +} + +// AddSortItems appends a child element to the sortItems list. +func (o *GridSortBar) AddSortItems(v element.Element) { + o.sortItems.Append(v) +} + +// RemoveSortItems removes the element at the given index from the sortItems list. +func (o *GridSortBar) RemoveSortItems(index int) { + o.sortItems.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridSortBar) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "SortItems"); err == nil { + for _, child := range children { + o.sortItems.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// GridSortItem +// ──────────────────────────────────────────────────────── + +type GridSortItem struct { + element.Base + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + sortDirection *property.Enum[string] +} + +// AttributePath returns the value of the attributePath property. +func (o *GridSortItem) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *GridSortItem) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *GridSortItem) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *GridSortItem) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// SortDirection returns the value of the sortDirection property. +func (o *GridSortItem) SortDirection() string { + return o.sortDirection.Get() +} + +// SetSortDirection sets the value of the sortDirection property. +func (o *GridSortItem) SetSortDirection(v string) { + o.sortDirection.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridSortItem) InitFromRaw(raw bson.Raw) { + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("SortDirection"); err == nil { + if s, ok := val.StringValueOK(); ok { o.sortDirection.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// GridXPathSource +// ──────────────────────────────────────────────────────── + +type GridXPathSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] + searchBar *property.Part[element.Element] + xPathConstraint *property.Primitive[string] + applyContext *property.Primitive[bool] + removeAllFromContext *property.Primitive[bool] + removeFromContextIds *property.ByNameRefList[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *GridXPathSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *GridXPathSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *GridXPathSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *GridXPathSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *GridXPathSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *GridXPathSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *GridXPathSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *GridXPathSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *GridXPathSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *GridXPathSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// SearchBar returns the value of the searchBar property. +func (o *GridXPathSource) SearchBar() element.Element { + return o.searchBar.Get() +} + +// SetSearchBar sets the value of the searchBar property. +func (o *GridXPathSource) SetSearchBar(v element.Element) { + o.searchBar.Set(v) +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *GridXPathSource) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *GridXPathSource) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// ApplyContext returns the value of the applyContext property. +func (o *GridXPathSource) ApplyContext() bool { + return o.applyContext.Get() +} + +// SetApplyContext sets the value of the applyContext property. +func (o *GridXPathSource) SetApplyContext(v bool) { + o.applyContext.Set(v) +} + +// RemoveAllFromContext returns the value of the removeAllFromContext property. +func (o *GridXPathSource) RemoveAllFromContext() bool { + return o.removeAllFromContext.Get() +} + +// SetRemoveAllFromContext sets the value of the removeAllFromContext property. +func (o *GridXPathSource) SetRemoveAllFromContext(v bool) { + o.removeAllFromContext.Set(v) +} + +// RemoveFromContextIdsQualifiedNames returns the value of the removeFromContextIds property. +func (o *GridXPathSource) RemoveFromContextIdsQualifiedNames() []string { + return o.removeFromContextIds.QualifiedNames() +} + +// SetRemoveFromContextIdsQualifiedNames sets the value of the removeFromContextIds property. +func (o *GridXPathSource) SetRemoveFromContextIdsQualifiedNames(v []string) { + o.removeFromContextIds.SetQualifiedNames(v) +} + +// AddRemoveFromContextIds appends a child element to the removeFromContextIds list. +func (o *GridXPathSource) AddRemoveFromContextIds(v string) { + o.removeFromContextIds.Append(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GridXPathSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SearchBar"); err == nil { + o.searchBar.SetFromDecode(child) + } + o.xPathConstraint.Init(raw) + o.applyContext.Init(raw) + o.removeAllFromContext.Init(raw) + if val, err := raw.LookupErr("RemoveFromContextIds"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.removeFromContextIds.SetFromDecode(qnames) + } + } +} + +// ──────────────────────────────────────────────────────── +// GroupBox +// ──────────────────────────────────────────────────────── + +type GroupBox struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + collapsible *property.Enum[string] + headerMode *property.Enum[string] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *GroupBox) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *GroupBox) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *GroupBox) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *GroupBox) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *GroupBox) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *GroupBox) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *GroupBox) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *GroupBox) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *GroupBox) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *GroupBox) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *GroupBox) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *GroupBox) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *GroupBox) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *GroupBox) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *GroupBox) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *GroupBox) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Collapsible returns the value of the collapsible property. +func (o *GroupBox) Collapsible() string { + return o.collapsible.Get() +} + +// SetCollapsible sets the value of the collapsible property. +func (o *GroupBox) SetCollapsible(v string) { + o.collapsible.Set(v) +} + +// HeaderMode returns the value of the headerMode property. +func (o *GroupBox) HeaderMode() string { + return o.headerMode.Get() +} + +// SetHeaderMode sets the value of the headerMode property. +func (o *GroupBox) SetHeaderMode(v string) { + o.headerMode.Set(v) +} + +// Widget returns the value of the widget property. +func (o *GroupBox) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *GroupBox) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *GroupBox) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *GroupBox) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *GroupBox) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *GroupBox) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if val, err := raw.LookupErr("Collapsible"); err == nil { + if s, ok := val.StringValueOK(); ok { o.collapsible.SetFromDecode(s) } + } + if val, err := raw.LookupErr("HeaderMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.headerMode.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Header +// ──────────────────────────────────────────────────────── + +type Header struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + leftWidget *property.Part[element.Element] + leftWidgets *property.PartList[element.Element] + rightWidget *property.Part[element.Element] + rightWidgets *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *Header) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Header) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *Header) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Header) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Header) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Header) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *Header) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *Header) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *Header) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *Header) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// LeftWidget returns the value of the leftWidget property. +func (o *Header) LeftWidget() element.Element { + return o.leftWidget.Get() +} + +// SetLeftWidget sets the value of the leftWidget property. +func (o *Header) SetLeftWidget(v element.Element) { + o.leftWidget.Set(v) +} + +// LeftWidgetsItems returns the value of the leftWidgets property. +func (o *Header) LeftWidgetsItems() []element.Element { + return o.leftWidgets.Items() +} + +// AddLeftWidgets appends a child element to the leftWidgets list. +func (o *Header) AddLeftWidgets(v element.Element) { + o.leftWidgets.Append(v) +} + +// RemoveLeftWidgets removes the element at the given index from the leftWidgets list. +func (o *Header) RemoveLeftWidgets(index int) { + o.leftWidgets.Remove(index) +} + +// RightWidget returns the value of the rightWidget property. +func (o *Header) RightWidget() element.Element { + return o.rightWidget.Get() +} + +// SetRightWidget sets the value of the rightWidget property. +func (o *Header) SetRightWidget(v element.Element) { + o.rightWidget.Set(v) +} + +// RightWidgetsItems returns the value of the rightWidgets property. +func (o *Header) RightWidgetsItems() []element.Element { + return o.rightWidgets.Items() +} + +// AddRightWidgets appends a child element to the rightWidgets list. +func (o *Header) AddRightWidgets(v element.Element) { + o.rightWidgets.Append(v) +} + +// RemoveRightWidgets removes the element at the given index from the rightWidgets list. +func (o *Header) RemoveRightWidgets(index int) { + o.rightWidgets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Header) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "LeftWidget"); err == nil { + o.leftWidget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "LeftWidgets"); err == nil { + for _, child := range children { + o.leftWidgets.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "RightWidget"); err == nil { + o.rightWidget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "RightWidgets"); err == nil { + for _, child := range children { + o.rightWidgets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// SplitPane +// ──────────────────────────────────────────────────────── + +type SplitPane struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + firstWidget *property.Part[element.Element] + secondWidget *property.Part[element.Element] + firstWidgets *property.PartList[element.Element] + secondWidgets *property.PartList[element.Element] + animatedResize *property.Primitive[bool] + height *property.Primitive[int32] + position *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *SplitPane) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SplitPane) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *SplitPane) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *SplitPane) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *SplitPane) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *SplitPane) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *SplitPane) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *SplitPane) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *SplitPane) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *SplitPane) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// FirstWidget returns the value of the firstWidget property. +func (o *SplitPane) FirstWidget() element.Element { + return o.firstWidget.Get() +} + +// SetFirstWidget sets the value of the firstWidget property. +func (o *SplitPane) SetFirstWidget(v element.Element) { + o.firstWidget.Set(v) +} + +// SecondWidget returns the value of the secondWidget property. +func (o *SplitPane) SecondWidget() element.Element { + return o.secondWidget.Get() +} + +// SetSecondWidget sets the value of the secondWidget property. +func (o *SplitPane) SetSecondWidget(v element.Element) { + o.secondWidget.Set(v) +} + +// FirstWidgetsItems returns the value of the firstWidgets property. +func (o *SplitPane) FirstWidgetsItems() []element.Element { + return o.firstWidgets.Items() +} + +// AddFirstWidgets appends a child element to the firstWidgets list. +func (o *SplitPane) AddFirstWidgets(v element.Element) { + o.firstWidgets.Append(v) +} + +// RemoveFirstWidgets removes the element at the given index from the firstWidgets list. +func (o *SplitPane) RemoveFirstWidgets(index int) { + o.firstWidgets.Remove(index) +} + +// SecondWidgetsItems returns the value of the secondWidgets property. +func (o *SplitPane) SecondWidgetsItems() []element.Element { + return o.secondWidgets.Items() +} + +// AddSecondWidgets appends a child element to the secondWidgets list. +func (o *SplitPane) AddSecondWidgets(v element.Element) { + o.secondWidgets.Append(v) +} + +// RemoveSecondWidgets removes the element at the given index from the secondWidgets list. +func (o *SplitPane) RemoveSecondWidgets(index int) { + o.secondWidgets.Remove(index) +} + +// AnimatedResize returns the value of the animatedResize property. +func (o *SplitPane) AnimatedResize() bool { + return o.animatedResize.Get() +} + +// SetAnimatedResize sets the value of the animatedResize property. +func (o *SplitPane) SetAnimatedResize(v bool) { + o.animatedResize.Set(v) +} + +// Height returns the value of the height property. +func (o *SplitPane) Height() int32 { + return o.height.Get() +} + +// SetHeight sets the value of the height property. +func (o *SplitPane) SetHeight(v int32) { + o.height.Set(v) +} + +// Position returns the value of the position property. +func (o *SplitPane) Position() int32 { + return o.position.Get() +} + +// SetPosition sets the value of the position property. +func (o *SplitPane) SetPosition(v int32) { + o.position.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SplitPane) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "FirstWidget"); err == nil { + o.firstWidget.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SecondWidget"); err == nil { + o.secondWidget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "FirstWidgets"); err == nil { + for _, child := range children { + o.firstWidgets.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "SecondWidgets"); err == nil { + for _, child := range children { + o.secondWidgets.AppendFromDecode(child) + } + } + o.animatedResize.Init(raw) + o.height.Init(raw) + o.position.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// HorizontalSplitPane +// ──────────────────────────────────────────────────────── + +type HorizontalSplitPane struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + firstWidget *property.Part[element.Element] + secondWidget *property.Part[element.Element] + firstWidgets *property.PartList[element.Element] + secondWidgets *property.PartList[element.Element] + animatedResize *property.Primitive[bool] + height *property.Primitive[int32] + position *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *HorizontalSplitPane) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *HorizontalSplitPane) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *HorizontalSplitPane) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *HorizontalSplitPane) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *HorizontalSplitPane) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *HorizontalSplitPane) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *HorizontalSplitPane) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *HorizontalSplitPane) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *HorizontalSplitPane) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *HorizontalSplitPane) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// FirstWidget returns the value of the firstWidget property. +func (o *HorizontalSplitPane) FirstWidget() element.Element { + return o.firstWidget.Get() +} + +// SetFirstWidget sets the value of the firstWidget property. +func (o *HorizontalSplitPane) SetFirstWidget(v element.Element) { + o.firstWidget.Set(v) +} + +// SecondWidget returns the value of the secondWidget property. +func (o *HorizontalSplitPane) SecondWidget() element.Element { + return o.secondWidget.Get() +} + +// SetSecondWidget sets the value of the secondWidget property. +func (o *HorizontalSplitPane) SetSecondWidget(v element.Element) { + o.secondWidget.Set(v) +} + +// FirstWidgetsItems returns the value of the firstWidgets property. +func (o *HorizontalSplitPane) FirstWidgetsItems() []element.Element { + return o.firstWidgets.Items() +} + +// AddFirstWidgets appends a child element to the firstWidgets list. +func (o *HorizontalSplitPane) AddFirstWidgets(v element.Element) { + o.firstWidgets.Append(v) +} + +// RemoveFirstWidgets removes the element at the given index from the firstWidgets list. +func (o *HorizontalSplitPane) RemoveFirstWidgets(index int) { + o.firstWidgets.Remove(index) +} + +// SecondWidgetsItems returns the value of the secondWidgets property. +func (o *HorizontalSplitPane) SecondWidgetsItems() []element.Element { + return o.secondWidgets.Items() +} + +// AddSecondWidgets appends a child element to the secondWidgets list. +func (o *HorizontalSplitPane) AddSecondWidgets(v element.Element) { + o.secondWidgets.Append(v) +} + +// RemoveSecondWidgets removes the element at the given index from the secondWidgets list. +func (o *HorizontalSplitPane) RemoveSecondWidgets(index int) { + o.secondWidgets.Remove(index) +} + +// AnimatedResize returns the value of the animatedResize property. +func (o *HorizontalSplitPane) AnimatedResize() bool { + return o.animatedResize.Get() +} + +// SetAnimatedResize sets the value of the animatedResize property. +func (o *HorizontalSplitPane) SetAnimatedResize(v bool) { + o.animatedResize.Set(v) +} + +// Height returns the value of the height property. +func (o *HorizontalSplitPane) Height() int32 { + return o.height.Get() +} + +// SetHeight sets the value of the height property. +func (o *HorizontalSplitPane) SetHeight(v int32) { + o.height.Set(v) +} + +// Position returns the value of the position property. +func (o *HorizontalSplitPane) Position() int32 { + return o.position.Get() +} + +// SetPosition sets the value of the position property. +func (o *HorizontalSplitPane) SetPosition(v int32) { + o.position.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *HorizontalSplitPane) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "FirstWidget"); err == nil { + o.firstWidget.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SecondWidget"); err == nil { + o.secondWidget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "FirstWidgets"); err == nil { + for _, child := range children { + o.firstWidgets.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "SecondWidgets"); err == nil { + for _, child := range children { + o.secondWidgets.AppendFromDecode(child) + } + } + o.animatedResize.Init(raw) + o.height.Init(raw) + o.position.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// IconCollectionIcon +// ──────────────────────────────────────────────────────── + +type IconCollectionIcon struct { + element.Base + image *property.ByNameRef[element.Element] +} + +// ImageQualifiedName returns the value of the image property. +func (o *IconCollectionIcon) ImageQualifiedName() string { + return o.image.QualifiedName() +} + +// SetImageQualifiedName sets the value of the image property. +func (o *IconCollectionIcon) SetImageQualifiedName(v string) { + o.image.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IconCollectionIcon) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Image"); err == nil { + if s, ok := val.StringValueOK(); ok { o.image.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ImageIcon +// ──────────────────────────────────────────────────────── + +type ImageIcon struct { + element.Base + image *property.ByNameRef[element.Element] +} + +// ImageQualifiedName returns the value of the image property. +func (o *ImageIcon) ImageQualifiedName() string { + return o.image.QualifiedName() +} + +// SetImageQualifiedName sets the value of the image property. +func (o *ImageIcon) SetImageQualifiedName(v string) { + o.image.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImageIcon) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Image"); err == nil { + if s, ok := val.StringValueOK(); ok { o.image.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ImageUploader +// ──────────────────────────────────────────────────────── + +type ImageUploader struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + allowedExtensions *property.Primitive[string] + thumbnailSize *property.Primitive[string] + maxFileSize *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *ImageUploader) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ImageUploader) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ImageUploader) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ImageUploader) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ImageUploader) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ImageUploader) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ImageUploader) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ImageUploader) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ImageUploader) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ImageUploader) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *ImageUploader) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *ImageUploader) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *ImageUploader) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *ImageUploader) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *ImageUploader) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *ImageUploader) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *ImageUploader) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *ImageUploader) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *ImageUploader) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *ImageUploader) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *ImageUploader) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *ImageUploader) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *ImageUploader) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *ImageUploader) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AllowedExtensions returns the value of the allowedExtensions property. +func (o *ImageUploader) AllowedExtensions() string { + return o.allowedExtensions.Get() +} + +// SetAllowedExtensions sets the value of the allowedExtensions property. +func (o *ImageUploader) SetAllowedExtensions(v string) { + o.allowedExtensions.Set(v) +} + +// ThumbnailSize returns the value of the thumbnailSize property. +func (o *ImageUploader) ThumbnailSize() string { + return o.thumbnailSize.Get() +} + +// SetThumbnailSize sets the value of the thumbnailSize property. +func (o *ImageUploader) SetThumbnailSize(v string) { + o.thumbnailSize.Set(v) +} + +// MaxFileSize returns the value of the maxFileSize property. +func (o *ImageUploader) MaxFileSize() int32 { + return o.maxFileSize.Get() +} + +// SetMaxFileSize sets the value of the maxFileSize property. +func (o *ImageUploader) SetMaxFileSize(v int32) { + o.maxFileSize.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImageUploader) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.allowedExtensions.Init(raw) + o.thumbnailSize.Init(raw) + o.maxFileSize.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ImageViewerSource +// ──────────────────────────────────────────────────────── + +type ImageViewerSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *ImageViewerSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *ImageViewerSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *ImageViewerSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *ImageViewerSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *ImageViewerSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *ImageViewerSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ImageViewerSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ImageViewerSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImageViewerSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// InputReferenceSetSelector +// ──────────────────────────────────────────────────────── + +type InputReferenceSetSelector struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + selectorSource *property.Part[element.Element] + selectPageSettings *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *InputReferenceSetSelector) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *InputReferenceSetSelector) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *InputReferenceSetSelector) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *InputReferenceSetSelector) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *InputReferenceSetSelector) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *InputReferenceSetSelector) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *InputReferenceSetSelector) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *InputReferenceSetSelector) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *InputReferenceSetSelector) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *InputReferenceSetSelector) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *InputReferenceSetSelector) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *InputReferenceSetSelector) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *InputReferenceSetSelector) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *InputReferenceSetSelector) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *InputReferenceSetSelector) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *InputReferenceSetSelector) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *InputReferenceSetSelector) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *InputReferenceSetSelector) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *InputReferenceSetSelector) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *InputReferenceSetSelector) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *InputReferenceSetSelector) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *InputReferenceSetSelector) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *InputReferenceSetSelector) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *InputReferenceSetSelector) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *InputReferenceSetSelector) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *InputReferenceSetSelector) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *InputReferenceSetSelector) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *InputReferenceSetSelector) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *InputReferenceSetSelector) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *InputReferenceSetSelector) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// SelectorSource returns the value of the selectorSource property. +func (o *InputReferenceSetSelector) SelectorSource() element.Element { + return o.selectorSource.Get() +} + +// SetSelectorSource sets the value of the selectorSource property. +func (o *InputReferenceSetSelector) SetSelectorSource(v element.Element) { + o.selectorSource.Set(v) +} + +// SelectPageSettings returns the value of the selectPageSettings property. +func (o *InputReferenceSetSelector) SelectPageSettings() element.Element { + return o.selectPageSettings.Get() +} + +// SetSelectPageSettings sets the value of the selectPageSettings property. +func (o *InputReferenceSetSelector) SetSelectPageSettings(v element.Element) { + o.selectPageSettings.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *InputReferenceSetSelector) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *InputReferenceSetSelector) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *InputReferenceSetSelector) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *InputReferenceSetSelector) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *InputReferenceSetSelector) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *InputReferenceSetSelector) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *InputReferenceSetSelector) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "SelectorSource"); err == nil { + o.selectorSource.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SelectPageSettings"); err == nil { + o.selectPageSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Label +// ──────────────────────────────────────────────────────── + +type Label struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *Label) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Label) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *Label) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Label) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Label) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Label) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *Label) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *Label) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *Label) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *Label) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *Label) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *Label) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *Label) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *Label) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *Label) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *Label) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Label) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Layout +// ──────────────────────────────────────────────────────── + +type Layout struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + canvasWidth *property.Primitive[int32] + canvasHeight *property.Primitive[int32] + content *property.Part[element.Element] + appearance *property.Part[element.Element] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + layoutCall *property.Part[element.Element] + layoutType *property.Enum[string] + mainPlaceholder *property.ByNameRef[element.Element] + acceptButtonPlaceholder *property.ByNameRef[element.Element] + cancelButtonPlaceholder *property.ByNameRef[element.Element] + mainPlaceholderName *property.Primitive[string] + acceptPlaceholderName *property.Primitive[string] + cancelPlaceholderName *property.Primitive[string] + useMainPlaceholderForPopups *property.Primitive[bool] + class *property.Primitive[string] + style *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *Layout) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Layout) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Layout) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Layout) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Layout) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Layout) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Layout) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Layout) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CanvasWidth returns the value of the canvasWidth property. +func (o *Layout) CanvasWidth() int32 { + return o.canvasWidth.Get() +} + +// SetCanvasWidth sets the value of the canvasWidth property. +func (o *Layout) SetCanvasWidth(v int32) { + o.canvasWidth.Set(v) +} + +// CanvasHeight returns the value of the canvasHeight property. +func (o *Layout) CanvasHeight() int32 { + return o.canvasHeight.Get() +} + +// SetCanvasHeight sets the value of the canvasHeight property. +func (o *Layout) SetCanvasHeight(v int32) { + o.canvasHeight.Set(v) +} + +// Content returns the value of the content property. +func (o *Layout) Content() element.Element { + return o.content.Get() +} + +// SetContent sets the value of the content property. +func (o *Layout) SetContent(v element.Element) { + o.content.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *Layout) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *Layout) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// Widget returns the value of the widget property. +func (o *Layout) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *Layout) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *Layout) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *Layout) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *Layout) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// LayoutCall returns the value of the layoutCall property. +func (o *Layout) LayoutCall() element.Element { + return o.layoutCall.Get() +} + +// SetLayoutCall sets the value of the layoutCall property. +func (o *Layout) SetLayoutCall(v element.Element) { + o.layoutCall.Set(v) +} + +// LayoutType returns the value of the layoutType property. +func (o *Layout) LayoutType() string { + return o.layoutType.Get() +} + +// SetLayoutType sets the value of the layoutType property. +func (o *Layout) SetLayoutType(v string) { + o.layoutType.Set(v) +} + +// MainPlaceholderQualifiedName returns the value of the mainPlaceholder property. +func (o *Layout) MainPlaceholderQualifiedName() string { + return o.mainPlaceholder.QualifiedName() +} + +// SetMainPlaceholderQualifiedName sets the value of the mainPlaceholder property. +func (o *Layout) SetMainPlaceholderQualifiedName(v string) { + o.mainPlaceholder.SetQualifiedName(v) +} + +// AcceptButtonPlaceholderQualifiedName returns the value of the acceptButtonPlaceholder property. +func (o *Layout) AcceptButtonPlaceholderQualifiedName() string { + return o.acceptButtonPlaceholder.QualifiedName() +} + +// SetAcceptButtonPlaceholderQualifiedName sets the value of the acceptButtonPlaceholder property. +func (o *Layout) SetAcceptButtonPlaceholderQualifiedName(v string) { + o.acceptButtonPlaceholder.SetQualifiedName(v) +} + +// CancelButtonPlaceholderQualifiedName returns the value of the cancelButtonPlaceholder property. +func (o *Layout) CancelButtonPlaceholderQualifiedName() string { + return o.cancelButtonPlaceholder.QualifiedName() +} + +// SetCancelButtonPlaceholderQualifiedName sets the value of the cancelButtonPlaceholder property. +func (o *Layout) SetCancelButtonPlaceholderQualifiedName(v string) { + o.cancelButtonPlaceholder.SetQualifiedName(v) +} + +// MainPlaceholderName returns the value of the mainPlaceholderName property. +func (o *Layout) MainPlaceholderName() string { + return o.mainPlaceholderName.Get() +} + +// SetMainPlaceholderName sets the value of the mainPlaceholderName property. +func (o *Layout) SetMainPlaceholderName(v string) { + o.mainPlaceholderName.Set(v) +} + +// AcceptPlaceholderName returns the value of the acceptPlaceholderName property. +func (o *Layout) AcceptPlaceholderName() string { + return o.acceptPlaceholderName.Get() +} + +// SetAcceptPlaceholderName sets the value of the acceptPlaceholderName property. +func (o *Layout) SetAcceptPlaceholderName(v string) { + o.acceptPlaceholderName.Set(v) +} + +// CancelPlaceholderName returns the value of the cancelPlaceholderName property. +func (o *Layout) CancelPlaceholderName() string { + return o.cancelPlaceholderName.Get() +} + +// SetCancelPlaceholderName sets the value of the cancelPlaceholderName property. +func (o *Layout) SetCancelPlaceholderName(v string) { + o.cancelPlaceholderName.Set(v) +} + +// UseMainPlaceholderForPopups returns the value of the useMainPlaceholderForPopups property. +func (o *Layout) UseMainPlaceholderForPopups() bool { + return o.useMainPlaceholderForPopups.Get() +} + +// SetUseMainPlaceholderForPopups sets the value of the useMainPlaceholderForPopups property. +func (o *Layout) SetUseMainPlaceholderForPopups(v bool) { + o.useMainPlaceholderForPopups.Set(v) +} + +// Class returns the value of the class property. +func (o *Layout) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Layout) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Layout) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Layout) SetStyle(v string) { + o.style.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Layout) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.canvasWidth.Init(raw) + o.canvasHeight.Init(raw) + if child, err := codec.DecodeChild(raw, "Content"); err == nil { + o.content.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "LayoutCall"); err == nil { + o.layoutCall.SetFromDecode(child) + } + if val, err := raw.LookupErr("LayoutType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.layoutType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("MainPlaceholder"); err == nil { + if s, ok := val.StringValueOK(); ok { o.mainPlaceholder.SetFromDecode(s) } + } + if val, err := raw.LookupErr("AcceptButtonPlaceholder"); err == nil { + if s, ok := val.StringValueOK(); ok { o.acceptButtonPlaceholder.SetFromDecode(s) } + } + if val, err := raw.LookupErr("CancelButtonPlaceholder"); err == nil { + if s, ok := val.StringValueOK(); ok { o.cancelButtonPlaceholder.SetFromDecode(s) } + } + o.mainPlaceholderName.Init(raw) + o.acceptPlaceholderName.Init(raw) + o.cancelPlaceholderName.Init(raw) + o.useMainPlaceholderForPopups.Init(raw) + o.class.Init(raw) + o.style.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LayoutCall +// ──────────────────────────────────────────────────────── + +type LayoutCall struct { + element.Base + layout *property.ByNameRef[element.Element] + arguments *property.PartList[element.Element] +} + +// LayoutQualifiedName returns the value of the layout property. +func (o *LayoutCall) LayoutQualifiedName() string { + return o.layout.QualifiedName() +} + +// SetLayoutQualifiedName sets the value of the layout property. +func (o *LayoutCall) SetLayoutQualifiedName(v string) { + o.layout.SetQualifiedName(v) +} + +// ArgumentsItems returns the value of the arguments property. +func (o *LayoutCall) ArgumentsItems() []element.Element { + return o.arguments.Items() +} + +// AddArguments appends a child element to the arguments list. +func (o *LayoutCall) AddArguments(v element.Element) { + o.arguments.Append(v) +} + +// RemoveArguments removes the element at the given index from the arguments list. +func (o *LayoutCall) RemoveArguments(index int) { + o.arguments.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LayoutCall) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Layout"); err == nil { + if s, ok := val.StringValueOK(); ok { o.layout.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Arguments"); err == nil { + for _, child := range children { + o.arguments.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// LayoutCallArgument +// ──────────────────────────────────────────────────────── + +type LayoutCallArgument struct { + element.Base + parameterName *property.Primitive[string] + parameter *property.ByNameRef[element.Element] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] +} + +// ParameterName returns the value of the parameterName property. +func (o *LayoutCallArgument) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *LayoutCallArgument) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *LayoutCallArgument) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *LayoutCallArgument) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Widget returns the value of the widget property. +func (o *LayoutCallArgument) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *LayoutCallArgument) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *LayoutCallArgument) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *LayoutCallArgument) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *LayoutCallArgument) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LayoutCallArgument) InitFromRaw(raw bson.Raw) { + o.parameterName.Init(raw) + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// LayoutContent +// ──────────────────────────────────────────────────────── + +type LayoutContent struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LayoutContent) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// LayoutGrid +// ──────────────────────────────────────────────────────── + +type LayoutGrid struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + width *property.Enum[string] + rows *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *LayoutGrid) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *LayoutGrid) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *LayoutGrid) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *LayoutGrid) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *LayoutGrid) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *LayoutGrid) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *LayoutGrid) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *LayoutGrid) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *LayoutGrid) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *LayoutGrid) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *LayoutGrid) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *LayoutGrid) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *LayoutGrid) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *LayoutGrid) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Width returns the value of the width property. +func (o *LayoutGrid) Width() string { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *LayoutGrid) SetWidth(v string) { + o.width.Set(v) +} + +// RowsItems returns the value of the rows property. +func (o *LayoutGrid) RowsItems() []element.Element { + return o.rows.Items() +} + +// AddRows appends a child element to the rows list. +func (o *LayoutGrid) AddRows(v element.Element) { + o.rows.Append(v) +} + +// RemoveRows removes the element at the given index from the rows list. +func (o *LayoutGrid) RemoveRows(index int) { + o.rows.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LayoutGrid) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Width"); err == nil { + if s, ok := val.StringValueOK(); ok { o.width.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Rows"); err == nil { + for _, child := range children { + o.rows.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// LayoutGridColumn +// ──────────────────────────────────────────────────────── + +type LayoutGridColumn struct { + element.Base + weight *property.Primitive[int32] + tabletWeight *property.Primitive[int32] + phoneWeight *property.Primitive[int32] + previewWidth *property.Primitive[int32] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + verticalAlignment *property.Enum[string] +} + +// Weight returns the value of the weight property. +func (o *LayoutGridColumn) Weight() int32 { + return o.weight.Get() +} + +// SetWeight sets the value of the weight property. +func (o *LayoutGridColumn) SetWeight(v int32) { + o.weight.Set(v) +} + +// TabletWeight returns the value of the tabletWeight property. +func (o *LayoutGridColumn) TabletWeight() int32 { + return o.tabletWeight.Get() +} + +// SetTabletWeight sets the value of the tabletWeight property. +func (o *LayoutGridColumn) SetTabletWeight(v int32) { + o.tabletWeight.Set(v) +} + +// PhoneWeight returns the value of the phoneWeight property. +func (o *LayoutGridColumn) PhoneWeight() int32 { + return o.phoneWeight.Get() +} + +// SetPhoneWeight sets the value of the phoneWeight property. +func (o *LayoutGridColumn) SetPhoneWeight(v int32) { + o.phoneWeight.Set(v) +} + +// PreviewWidth returns the value of the previewWidth property. +func (o *LayoutGridColumn) PreviewWidth() int32 { + return o.previewWidth.Get() +} + +// SetPreviewWidth sets the value of the previewWidth property. +func (o *LayoutGridColumn) SetPreviewWidth(v int32) { + o.previewWidth.Set(v) +} + +// Widget returns the value of the widget property. +func (o *LayoutGridColumn) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *LayoutGridColumn) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *LayoutGridColumn) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *LayoutGridColumn) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *LayoutGridColumn) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// Class returns the value of the class property. +func (o *LayoutGridColumn) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *LayoutGridColumn) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *LayoutGridColumn) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *LayoutGridColumn) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *LayoutGridColumn) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *LayoutGridColumn) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// VerticalAlignment returns the value of the verticalAlignment property. +func (o *LayoutGridColumn) VerticalAlignment() string { + return o.verticalAlignment.Get() +} + +// SetVerticalAlignment sets the value of the verticalAlignment property. +func (o *LayoutGridColumn) SetVerticalAlignment(v string) { + o.verticalAlignment.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LayoutGridColumn) InitFromRaw(raw bson.Raw) { + o.weight.Init(raw) + o.tabletWeight.Init(raw) + o.phoneWeight.Init(raw) + o.previewWidth.Init(raw) + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if val, err := raw.LookupErr("VerticalAlignment"); err == nil { + if s, ok := val.StringValueOK(); ok { o.verticalAlignment.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// LayoutGridRow +// ──────────────────────────────────────────────────────── + +type LayoutGridRow struct { + element.Base + columns *property.PartList[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + verticalAlignment *property.Enum[string] + horizontalAlignment *property.Enum[string] + spacingBetweenColumns *property.Primitive[bool] +} + +// ColumnsItems returns the value of the columns property. +func (o *LayoutGridRow) ColumnsItems() []element.Element { + return o.columns.Items() +} + +// AddColumns appends a child element to the columns list. +func (o *LayoutGridRow) AddColumns(v element.Element) { + o.columns.Append(v) +} + +// RemoveColumns removes the element at the given index from the columns list. +func (o *LayoutGridRow) RemoveColumns(index int) { + o.columns.Remove(index) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *LayoutGridRow) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *LayoutGridRow) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// Class returns the value of the class property. +func (o *LayoutGridRow) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *LayoutGridRow) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *LayoutGridRow) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *LayoutGridRow) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *LayoutGridRow) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *LayoutGridRow) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// VerticalAlignment returns the value of the verticalAlignment property. +func (o *LayoutGridRow) VerticalAlignment() string { + return o.verticalAlignment.Get() +} + +// SetVerticalAlignment sets the value of the verticalAlignment property. +func (o *LayoutGridRow) SetVerticalAlignment(v string) { + o.verticalAlignment.Set(v) +} + +// HorizontalAlignment returns the value of the horizontalAlignment property. +func (o *LayoutGridRow) HorizontalAlignment() string { + return o.horizontalAlignment.Get() +} + +// SetHorizontalAlignment sets the value of the horizontalAlignment property. +func (o *LayoutGridRow) SetHorizontalAlignment(v string) { + o.horizontalAlignment.Set(v) +} + +// SpacingBetweenColumns returns the value of the spacingBetweenColumns property. +func (o *LayoutGridRow) SpacingBetweenColumns() bool { + return o.spacingBetweenColumns.Get() +} + +// SetSpacingBetweenColumns sets the value of the spacingBetweenColumns property. +func (o *LayoutGridRow) SetSpacingBetweenColumns(v bool) { + o.spacingBetweenColumns.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LayoutGridRow) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Columns"); err == nil { + for _, child := range children { + o.columns.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if val, err := raw.LookupErr("VerticalAlignment"); err == nil { + if s, ok := val.StringValueOK(); ok { o.verticalAlignment.SetFromDecode(s) } + } + if val, err := raw.LookupErr("HorizontalAlignment"); err == nil { + if s, ok := val.StringValueOK(); ok { o.horizontalAlignment.SetFromDecode(s) } + } + o.spacingBetweenColumns.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LayoutParameter +// ──────────────────────────────────────────────────────── + +type LayoutParameter struct { + element.Base + name *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *LayoutParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *LayoutParameter) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LayoutParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LinkButton +// ──────────────────────────────────────────────────────── + +type LinkButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] + linkType *property.Enum[string] + address *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *LinkButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *LinkButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *LinkButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *LinkButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *LinkButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *LinkButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *LinkButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *LinkButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *LinkButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *LinkButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *LinkButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *LinkButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *LinkButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *LinkButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *LinkButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *LinkButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *LinkButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *LinkButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *LinkButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *LinkButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *LinkButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *LinkButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *LinkButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *LinkButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// LinkType returns the value of the linkType property. +func (o *LinkButton) LinkType() string { + return o.linkType.Get() +} + +// SetLinkType sets the value of the linkType property. +func (o *LinkButton) SetLinkType(v string) { + o.linkType.Set(v) +} + +// Address returns the value of the address property. +func (o *LinkButton) Address() element.Element { + return o.address.Get() +} + +// SetAddress sets the value of the address property. +func (o *LinkButton) SetAddress(v element.Element) { + o.address.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LinkButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + if val, err := raw.LookupErr("LinkType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.linkType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Address"); err == nil { + o.address.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ListView +// ──────────────────────────────────────────────────────── + +type ListView struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + dataSource *property.Part[element.Element] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + pageSize *property.Primitive[int32] + clickAction *property.Part[element.Element] + editable *property.Primitive[bool] + templates *property.PartList[element.Element] + scrollDirection *property.Enum[string] + numberOfColumns *property.Primitive[int32] + pullDownAction *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *ListView) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ListView) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ListView) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ListView) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ListView) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ListView) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ListView) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ListView) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ListView) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ListView) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *ListView) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *ListView) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *ListView) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *ListView) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// DataSource returns the value of the dataSource property. +func (o *ListView) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *ListView) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// Widget returns the value of the widget property. +func (o *ListView) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *ListView) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *ListView) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *ListView) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *ListView) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// PageSize returns the value of the pageSize property. +func (o *ListView) PageSize() int32 { + return o.pageSize.Get() +} + +// SetPageSize sets the value of the pageSize property. +func (o *ListView) SetPageSize(v int32) { + o.pageSize.Set(v) +} + +// ClickAction returns the value of the clickAction property. +func (o *ListView) ClickAction() element.Element { + return o.clickAction.Get() +} + +// SetClickAction sets the value of the clickAction property. +func (o *ListView) SetClickAction(v element.Element) { + o.clickAction.Set(v) +} + +// Editable returns the value of the editable property. +func (o *ListView) Editable() bool { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *ListView) SetEditable(v bool) { + o.editable.Set(v) +} + +// TemplatesItems returns the value of the templates property. +func (o *ListView) TemplatesItems() []element.Element { + return o.templates.Items() +} + +// AddTemplates appends a child element to the templates list. +func (o *ListView) AddTemplates(v element.Element) { + o.templates.Append(v) +} + +// RemoveTemplates removes the element at the given index from the templates list. +func (o *ListView) RemoveTemplates(index int) { + o.templates.Remove(index) +} + +// ScrollDirection returns the value of the scrollDirection property. +func (o *ListView) ScrollDirection() string { + return o.scrollDirection.Get() +} + +// SetScrollDirection sets the value of the scrollDirection property. +func (o *ListView) SetScrollDirection(v string) { + o.scrollDirection.Set(v) +} + +// NumberOfColumns returns the value of the numberOfColumns property. +func (o *ListView) NumberOfColumns() int32 { + return o.numberOfColumns.Get() +} + +// SetNumberOfColumns sets the value of the numberOfColumns property. +func (o *ListView) SetNumberOfColumns(v int32) { + o.numberOfColumns.Set(v) +} + +// PullDownAction returns the value of the pullDownAction property. +func (o *ListView) PullDownAction() element.Element { + return o.pullDownAction.Get() +} + +// SetPullDownAction sets the value of the pullDownAction property. +func (o *ListView) SetPullDownAction(v element.Element) { + o.pullDownAction.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListView) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + o.pageSize.Init(raw) + if child, err := codec.DecodeChild(raw, "ClickAction"); err == nil { + o.clickAction.SetFromDecode(child) + } + o.editable.Init(raw) + if children, err := codec.DecodeChildren(raw, "Templates"); err == nil { + for _, child := range children { + o.templates.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("ScrollDirection"); err == nil { + if s, ok := val.StringValueOK(); ok { o.scrollDirection.SetFromDecode(s) } + } + o.numberOfColumns.Init(raw) + if child, err := codec.DecodeChild(raw, "PullDownAction"); err == nil { + o.pullDownAction.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ListViewDatabaseSource +// ──────────────────────────────────────────────────────── + +type ListViewDatabaseSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] + databaseConstraints *property.PartList[element.Element] + search *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *ListViewDatabaseSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *ListViewDatabaseSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *ListViewDatabaseSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *ListViewDatabaseSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *ListViewDatabaseSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *ListViewDatabaseSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ListViewDatabaseSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ListViewDatabaseSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *ListViewDatabaseSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *ListViewDatabaseSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// DatabaseConstraintsItems returns the value of the databaseConstraints property. +func (o *ListViewDatabaseSource) DatabaseConstraintsItems() []element.Element { + return o.databaseConstraints.Items() +} + +// AddDatabaseConstraints appends a child element to the databaseConstraints list. +func (o *ListViewDatabaseSource) AddDatabaseConstraints(v element.Element) { + o.databaseConstraints.Append(v) +} + +// RemoveDatabaseConstraints removes the element at the given index from the databaseConstraints list. +func (o *ListViewDatabaseSource) RemoveDatabaseConstraints(index int) { + o.databaseConstraints.Remove(index) +} + +// Search returns the value of the search property. +func (o *ListViewDatabaseSource) Search() element.Element { + return o.search.Get() +} + +// SetSearch sets the value of the search property. +func (o *ListViewDatabaseSource) SetSearch(v element.Element) { + o.search.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListViewDatabaseSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "DatabaseConstraints"); err == nil { + for _, child := range children { + o.databaseConstraints.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Search"); err == nil { + o.search.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ListViewSearch +// ──────────────────────────────────────────────────────── + +type ListViewSearch struct { + element.Base + searchPaths *property.Primitive[string] + searchRefs *property.PartList[element.Element] +} + +// SearchPaths returns the value of the searchPaths property. +func (o *ListViewSearch) SearchPaths() string { + return o.searchPaths.Get() +} + +// SearchRefsItems returns the value of the searchRefs property. +func (o *ListViewSearch) SearchRefsItems() []element.Element { + return o.searchRefs.Items() +} + +// AddSearchRefs appends a child element to the searchRefs list. +func (o *ListViewSearch) AddSearchRefs(v element.Element) { + o.searchRefs.Append(v) +} + +// RemoveSearchRefs removes the element at the given index from the searchRefs list. +func (o *ListViewSearch) RemoveSearchRefs(index int) { + o.searchRefs.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListViewSearch) InitFromRaw(raw bson.Raw) { + o.searchPaths.Init(raw) + if children, err := codec.DecodeChildren(raw, "SearchRefs"); err == nil { + for _, child := range children { + o.searchRefs.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ListViewTemplate +// ──────────────────────────────────────────────────────── + +type ListViewTemplate struct { + element.Base + specialization *property.ByNameRef[element.Element] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] +} + +// SpecializationQualifiedName returns the value of the specialization property. +func (o *ListViewTemplate) SpecializationQualifiedName() string { + return o.specialization.QualifiedName() +} + +// SetSpecializationQualifiedName sets the value of the specialization property. +func (o *ListViewTemplate) SetSpecializationQualifiedName(v string) { + o.specialization.SetQualifiedName(v) +} + +// Widget returns the value of the widget property. +func (o *ListViewTemplate) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *ListViewTemplate) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *ListViewTemplate) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *ListViewTemplate) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *ListViewTemplate) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListViewTemplate) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Specialization"); err == nil { + if s, ok := val.StringValueOK(); ok { o.specialization.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// XPathSourceBase +// ──────────────────────────────────────────────────────── + +type XPathSourceBase struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] + xPathConstraint *property.Primitive[string] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *XPathSourceBase) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *XPathSourceBase) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *XPathSourceBase) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *XPathSourceBase) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *XPathSourceBase) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *XPathSourceBase) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *XPathSourceBase) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *XPathSourceBase) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *XPathSourceBase) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *XPathSourceBase) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *XPathSourceBase) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *XPathSourceBase) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *XPathSourceBase) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + o.xPathConstraint.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ListViewXPathSource +// ──────────────────────────────────────────────────────── + +type ListViewXPathSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] + xPathConstraint *property.Primitive[string] + search *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *ListViewXPathSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *ListViewXPathSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *ListViewXPathSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *ListViewXPathSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *ListViewXPathSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *ListViewXPathSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ListViewXPathSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ListViewXPathSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *ListViewXPathSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *ListViewXPathSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *ListViewXPathSource) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *ListViewXPathSource) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// Search returns the value of the search property. +func (o *ListViewXPathSource) Search() element.Element { + return o.search.Get() +} + +// SetSearch sets the value of the search property. +func (o *ListViewXPathSource) SetSearch(v element.Element) { + o.search.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListViewXPathSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + o.xPathConstraint.Init(raw) + if child, err := codec.DecodeChild(raw, "Search"); err == nil { + o.search.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ListenTargetSource +// ──────────────────────────────────────────────────────── + +type ListenTargetSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + listenTarget *property.Primitive[string] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *ListenTargetSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *ListenTargetSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// ListenTarget returns the value of the listenTarget property. +func (o *ListenTargetSource) ListenTarget() string { + return o.listenTarget.Get() +} + +// SetListenTarget sets the value of the listenTarget property. +func (o *ListenTargetSource) SetListenTarget(v string) { + o.listenTarget.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ListenTargetSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.listenTarget.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LocalVariable +// ──────────────────────────────────────────────────────── + +type LocalVariable struct { + element.Base + name *property.Primitive[string] + variableType *property.Part[element.Element] + defaultValue *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *LocalVariable) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *LocalVariable) SetName(v string) { + o.name.Set(v) +} + +// VariableType returns the value of the variableType property. +func (o *LocalVariable) VariableType() element.Element { + return o.variableType.Get() +} + +// SetVariableType sets the value of the variableType property. +func (o *LocalVariable) SetVariableType(v element.Element) { + o.variableType.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *LocalVariable) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *LocalVariable) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LocalVariable) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "VariableType"); err == nil { + o.variableType.SetFromDecode(child) + } + o.defaultValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LoginButton +// ──────────────────────────────────────────────────────── + +type LoginButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] + validationMessageWidget *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *LoginButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *LoginButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *LoginButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *LoginButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *LoginButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *LoginButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *LoginButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *LoginButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *LoginButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *LoginButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *LoginButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *LoginButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *LoginButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *LoginButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *LoginButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *LoginButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *LoginButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *LoginButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *LoginButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *LoginButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *LoginButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *LoginButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *LoginButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *LoginButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// ValidationMessageWidget returns the value of the validationMessageWidget property. +func (o *LoginButton) ValidationMessageWidget() string { + return o.validationMessageWidget.Get() +} + +// SetValidationMessageWidget sets the value of the validationMessageWidget property. +func (o *LoginButton) SetValidationMessageWidget(v string) { + o.validationMessageWidget.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LoginButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + o.validationMessageWidget.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LoginTextBox +// ──────────────────────────────────────────────────────── + +type LoginTextBox struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + label *property.Part[element.Element] + labelWidth *property.Primitive[int32] + placeholder *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *LoginTextBox) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *LoginTextBox) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *LoginTextBox) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *LoginTextBox) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *LoginTextBox) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *LoginTextBox) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *LoginTextBox) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *LoginTextBox) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *LoginTextBox) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *LoginTextBox) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// Label returns the value of the label property. +func (o *LoginTextBox) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *LoginTextBox) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelWidth returns the value of the labelWidth property. +func (o *LoginTextBox) LabelWidth() int32 { + return o.labelWidth.Get() +} + +// SetLabelWidth sets the value of the labelWidth property. +func (o *LoginTextBox) SetLabelWidth(v int32) { + o.labelWidth.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *LoginTextBox) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *LoginTextBox) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LoginTextBox) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + o.labelWidth.Init(raw) + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// LoginIdTextBox +// ──────────────────────────────────────────────────────── + +type LoginIdTextBox struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + label *property.Part[element.Element] + labelWidth *property.Primitive[int32] + placeholder *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *LoginIdTextBox) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *LoginIdTextBox) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *LoginIdTextBox) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *LoginIdTextBox) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *LoginIdTextBox) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *LoginIdTextBox) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *LoginIdTextBox) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *LoginIdTextBox) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *LoginIdTextBox) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *LoginIdTextBox) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// Label returns the value of the label property. +func (o *LoginIdTextBox) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *LoginIdTextBox) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelWidth returns the value of the labelWidth property. +func (o *LoginIdTextBox) LabelWidth() int32 { + return o.labelWidth.Get() +} + +// SetLabelWidth sets the value of the labelWidth property. +func (o *LoginIdTextBox) SetLabelWidth(v int32) { + o.labelWidth.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *LoginIdTextBox) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *LoginIdTextBox) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LoginIdTextBox) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + o.labelWidth.Init(raw) + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// LogoutButton +// ──────────────────────────────────────────────────────── + +type LogoutButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *LogoutButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *LogoutButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *LogoutButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *LogoutButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *LogoutButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *LogoutButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *LogoutButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *LogoutButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *LogoutButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *LogoutButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *LogoutButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *LogoutButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *LogoutButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *LogoutButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *LogoutButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *LogoutButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *LogoutButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *LogoutButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *LogoutButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *LogoutButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *LogoutButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *LogoutButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *LogoutButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *LogoutButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LogoutButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MasterDetail +// ──────────────────────────────────────────────────────── + +type MasterDetail struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + master *property.Part[element.Element] + detail *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *MasterDetail) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MasterDetail) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *MasterDetail) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *MasterDetail) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *MasterDetail) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *MasterDetail) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *MasterDetail) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *MasterDetail) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *MasterDetail) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *MasterDetail) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// Master returns the value of the master property. +func (o *MasterDetail) Master() element.Element { + return o.master.Get() +} + +// SetMaster sets the value of the master property. +func (o *MasterDetail) SetMaster(v element.Element) { + o.master.Set(v) +} + +// Detail returns the value of the detail property. +func (o *MasterDetail) Detail() element.Element { + return o.detail.Get() +} + +// SetDetail sets the value of the detail property. +func (o *MasterDetail) SetDetail(v element.Element) { + o.detail.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MasterDetail) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "Master"); err == nil { + o.master.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Detail"); err == nil { + o.detail.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MasterDetailRegion +// ──────────────────────────────────────────────────────── + +type MasterDetailRegion struct { + element.Base + widget *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] +} + +// Widget returns the value of the widget property. +func (o *MasterDetailRegion) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *MasterDetailRegion) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// Class returns the value of the class property. +func (o *MasterDetailRegion) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *MasterDetailRegion) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *MasterDetailRegion) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *MasterDetailRegion) SetStyle(v string) { + o.style.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MasterDetailRegion) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MasterDetailDetailRegion +// ──────────────────────────────────────────────────────── + +type MasterDetailDetailRegion struct { + element.Base + widget *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + responsiveWeight *property.Primitive[int32] + tabletWeight *property.Primitive[int32] + title *property.Part[element.Element] +} + +// Widget returns the value of the widget property. +func (o *MasterDetailDetailRegion) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *MasterDetailDetailRegion) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// Class returns the value of the class property. +func (o *MasterDetailDetailRegion) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *MasterDetailDetailRegion) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *MasterDetailDetailRegion) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *MasterDetailDetailRegion) SetStyle(v string) { + o.style.Set(v) +} + +// ResponsiveWeight returns the value of the responsiveWeight property. +func (o *MasterDetailDetailRegion) ResponsiveWeight() int32 { + return o.responsiveWeight.Get() +} + +// SetResponsiveWeight sets the value of the responsiveWeight property. +func (o *MasterDetailDetailRegion) SetResponsiveWeight(v int32) { + o.responsiveWeight.Set(v) +} + +// TabletWeight returns the value of the tabletWeight property. +func (o *MasterDetailDetailRegion) TabletWeight() int32 { + return o.tabletWeight.Get() +} + +// SetTabletWeight sets the value of the tabletWeight property. +func (o *MasterDetailDetailRegion) SetTabletWeight(v int32) { + o.tabletWeight.Set(v) +} + +// Title returns the value of the title property. +func (o *MasterDetailDetailRegion) Title() element.Element { + return o.title.Get() +} + +// SetTitle sets the value of the title property. +func (o *MasterDetailDetailRegion) SetTitle(v element.Element) { + o.title.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MasterDetailDetailRegion) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + o.responsiveWeight.Init(raw) + o.tabletWeight.Init(raw) + if child, err := codec.DecodeChild(raw, "Title"); err == nil { + o.title.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MasterDetailMasterRegion +// ──────────────────────────────────────────────────────── + +type MasterDetailMasterRegion struct { + element.Base + widget *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + responsiveWeight *property.Primitive[int32] + tabletWeight *property.Primitive[int32] +} + +// Widget returns the value of the widget property. +func (o *MasterDetailMasterRegion) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *MasterDetailMasterRegion) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// Class returns the value of the class property. +func (o *MasterDetailMasterRegion) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *MasterDetailMasterRegion) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *MasterDetailMasterRegion) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *MasterDetailMasterRegion) SetStyle(v string) { + o.style.Set(v) +} + +// ResponsiveWeight returns the value of the responsiveWeight property. +func (o *MasterDetailMasterRegion) ResponsiveWeight() int32 { + return o.responsiveWeight.Get() +} + +// SetResponsiveWeight sets the value of the responsiveWeight property. +func (o *MasterDetailMasterRegion) SetResponsiveWeight(v int32) { + o.responsiveWeight.Set(v) +} + +// TabletWeight returns the value of the tabletWeight property. +func (o *MasterDetailMasterRegion) TabletWeight() int32 { + return o.tabletWeight.Get() +} + +// SetTabletWeight sets the value of the tabletWeight property. +func (o *MasterDetailMasterRegion) SetTabletWeight(v int32) { + o.tabletWeight.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MasterDetailMasterRegion) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + o.responsiveWeight.Init(raw) + o.tabletWeight.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MenuWidget +// ──────────────────────────────────────────────────────── + +type MenuWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + menuSource *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *MenuWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MenuWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *MenuWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *MenuWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *MenuWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *MenuWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *MenuWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *MenuWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *MenuWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *MenuWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// MenuSource returns the value of the menuSource property. +func (o *MenuWidget) MenuSource() element.Element { + return o.menuSource.Get() +} + +// SetMenuSource sets the value of the menuSource property. +func (o *MenuWidget) SetMenuSource(v element.Element) { + o.menuSource.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MenuWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "MenuSource"); err == nil { + o.menuSource.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MenuBar +// ──────────────────────────────────────────────────────── + +type MenuBar struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + menuSource *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *MenuBar) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MenuBar) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *MenuBar) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *MenuBar) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *MenuBar) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *MenuBar) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *MenuBar) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *MenuBar) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *MenuBar) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *MenuBar) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// MenuSource returns the value of the menuSource property. +func (o *MenuBar) MenuSource() element.Element { + return o.menuSource.Get() +} + +// SetMenuSource sets the value of the menuSource property. +func (o *MenuBar) SetMenuSource(v element.Element) { + o.menuSource.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MenuBar) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "MenuSource"); err == nil { + o.menuSource.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MenuSource +// ──────────────────────────────────────────────────────── + +type MenuSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MenuSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// MenuDocumentSource +// ──────────────────────────────────────────────────────── + +type MenuDocumentSource struct { + element.Base + menu *property.ByNameRef[element.Element] +} + +// MenuQualifiedName returns the value of the menu property. +func (o *MenuDocumentSource) MenuQualifiedName() string { + return o.menu.QualifiedName() +} + +// SetMenuQualifiedName sets the value of the menu property. +func (o *MenuDocumentSource) SetMenuQualifiedName(v string) { + o.menu.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MenuDocumentSource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Menu"); err == nil { + if s, ok := val.StringValueOK(); ok { o.menu.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowClientAction +// ──────────────────────────────────────────────────────── + +type MicroflowClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + microflowSettings *property.Part[element.Element] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *MicroflowClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *MicroflowClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// MicroflowSettings returns the value of the microflowSettings property. +func (o *MicroflowClientAction) MicroflowSettings() element.Element { + return o.microflowSettings.Get() +} + +// SetMicroflowSettings sets the value of the microflowSettings property. +func (o *MicroflowClientAction) SetMicroflowSettings(v element.Element) { + o.microflowSettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + if child, err := codec.DecodeChild(raw, "MicroflowSettings"); err == nil { + o.microflowSettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowParameterMapping +// ──────────────────────────────────────────────────────── + +type MicroflowParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + expression *property.Primitive[string] + variable *property.Part[element.Element] + widget *property.ByNameRef[element.Element] + useAllPages *property.Primitive[bool] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *MicroflowParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *MicroflowParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Expression returns the value of the expression property. +func (o *MicroflowParameterMapping) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *MicroflowParameterMapping) SetExpression(v string) { + o.expression.Set(v) +} + +// Variable returns the value of the variable property. +func (o *MicroflowParameterMapping) Variable() element.Element { + return o.variable.Get() +} + +// SetVariable sets the value of the variable property. +func (o *MicroflowParameterMapping) SetVariable(v element.Element) { + o.variable.Set(v) +} + +// WidgetQualifiedName returns the value of the widget property. +func (o *MicroflowParameterMapping) WidgetQualifiedName() string { + return o.widget.QualifiedName() +} + +// SetWidgetQualifiedName sets the value of the widget property. +func (o *MicroflowParameterMapping) SetWidgetQualifiedName(v string) { + o.widget.SetQualifiedName(v) +} + +// UseAllPages returns the value of the useAllPages property. +func (o *MicroflowParameterMapping) UseAllPages() bool { + return o.useAllPages.Get() +} + +// SetUseAllPages sets the value of the useAllPages property. +func (o *MicroflowParameterMapping) SetUseAllPages(v bool) { + o.useAllPages.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "Variable"); err == nil { + o.variable.SetFromDecode(child) + } + if val, err := raw.LookupErr("Widget"); err == nil { + if s, ok := val.StringValueOK(); ok { o.widget.SetFromDecode(s) } + } + o.useAllPages.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MicroflowSettings +// ──────────────────────────────────────────────────────── + +type MicroflowSettings struct { + element.Base + microflow *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] + useAllPages *property.Primitive[bool] + progressBar *property.Enum[string] + progressMessage *property.Part[element.Element] + asynchronous *property.Primitive[bool] + formValidations *property.Enum[string] + confirmationInfo *property.Part[element.Element] + outputMappings *property.PartList[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowSettings) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowSettings) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *MicroflowSettings) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *MicroflowSettings) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *MicroflowSettings) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// UseAllPages returns the value of the useAllPages property. +func (o *MicroflowSettings) UseAllPages() bool { + return o.useAllPages.Get() +} + +// SetUseAllPages sets the value of the useAllPages property. +func (o *MicroflowSettings) SetUseAllPages(v bool) { + o.useAllPages.Set(v) +} + +// ProgressBar returns the value of the progressBar property. +func (o *MicroflowSettings) ProgressBar() string { + return o.progressBar.Get() +} + +// SetProgressBar sets the value of the progressBar property. +func (o *MicroflowSettings) SetProgressBar(v string) { + o.progressBar.Set(v) +} + +// ProgressMessage returns the value of the progressMessage property. +func (o *MicroflowSettings) ProgressMessage() element.Element { + return o.progressMessage.Get() +} + +// SetProgressMessage sets the value of the progressMessage property. +func (o *MicroflowSettings) SetProgressMessage(v element.Element) { + o.progressMessage.Set(v) +} + +// Asynchronous returns the value of the asynchronous property. +func (o *MicroflowSettings) Asynchronous() bool { + return o.asynchronous.Get() +} + +// SetAsynchronous sets the value of the asynchronous property. +func (o *MicroflowSettings) SetAsynchronous(v bool) { + o.asynchronous.Set(v) +} + +// FormValidations returns the value of the formValidations property. +func (o *MicroflowSettings) FormValidations() string { + return o.formValidations.Get() +} + +// SetFormValidations sets the value of the formValidations property. +func (o *MicroflowSettings) SetFormValidations(v string) { + o.formValidations.Set(v) +} + +// ConfirmationInfo returns the value of the confirmationInfo property. +func (o *MicroflowSettings) ConfirmationInfo() element.Element { + return o.confirmationInfo.Get() +} + +// SetConfirmationInfo sets the value of the confirmationInfo property. +func (o *MicroflowSettings) SetConfirmationInfo(v element.Element) { + o.confirmationInfo.Set(v) +} + +// OutputMappingsItems returns the value of the outputMappings property. +func (o *MicroflowSettings) OutputMappingsItems() []element.Element { + return o.outputMappings.Items() +} + +// AddOutputMappings appends a child element to the outputMappings list. +func (o *MicroflowSettings) AddOutputMappings(v element.Element) { + o.outputMappings.Append(v) +} + +// RemoveOutputMappings removes the element at the given index from the outputMappings list. +func (o *MicroflowSettings) RemoveOutputMappings(index int) { + o.outputMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowSettings) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + o.useAllPages.Init(raw) + if val, err := raw.LookupErr("ProgressBar"); err == nil { + if s, ok := val.StringValueOK(); ok { o.progressBar.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ProgressMessage"); err == nil { + o.progressMessage.SetFromDecode(child) + } + o.asynchronous.Init(raw) + if val, err := raw.LookupErr("FormValidations"); err == nil { + if s, ok := val.StringValueOK(); ok { o.formValidations.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "ConfirmationInfo"); err == nil { + o.confirmationInfo.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "OutputMappings"); err == nil { + for _, child := range children { + o.outputMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowSource +// ──────────────────────────────────────────────────────── + +type MicroflowSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + microflowSettings *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *MicroflowSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *MicroflowSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// MicroflowSettings returns the value of the microflowSettings property. +func (o *MicroflowSource) MicroflowSettings() element.Element { + return o.microflowSettings.Get() +} + +// SetMicroflowSettings sets the value of the microflowSettings property. +func (o *MicroflowSource) SetMicroflowSettings(v element.Element) { + o.microflowSettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + if child, err := codec.DecodeChild(raw, "MicroflowSettings"); err == nil { + o.microflowSettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NamedValue +// ──────────────────────────────────────────────────────── + +type NamedValue struct { + element.Base + name *property.Primitive[string] + value *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *NamedValue) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NamedValue) SetName(v string) { + o.name.Set(v) +} + +// Value returns the value of the value property. +func (o *NamedValue) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *NamedValue) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NamedValue) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// NanoflowParameterMapping +// ──────────────────────────────────────────────────────── + +type NanoflowParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + expression *property.Primitive[string] + variable *property.Part[element.Element] + widget *property.ByNameRef[element.Element] + useAllPages *property.Primitive[bool] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *NanoflowParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *NanoflowParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Expression returns the value of the expression property. +func (o *NanoflowParameterMapping) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *NanoflowParameterMapping) SetExpression(v string) { + o.expression.Set(v) +} + +// Variable returns the value of the variable property. +func (o *NanoflowParameterMapping) Variable() element.Element { + return o.variable.Get() +} + +// SetVariable sets the value of the variable property. +func (o *NanoflowParameterMapping) SetVariable(v element.Element) { + o.variable.Set(v) +} + +// WidgetQualifiedName returns the value of the widget property. +func (o *NanoflowParameterMapping) WidgetQualifiedName() string { + return o.widget.QualifiedName() +} + +// SetWidgetQualifiedName sets the value of the widget property. +func (o *NanoflowParameterMapping) SetWidgetQualifiedName(v string) { + o.widget.SetQualifiedName(v) +} + +// UseAllPages returns the value of the useAllPages property. +func (o *NanoflowParameterMapping) UseAllPages() bool { + return o.useAllPages.Get() +} + +// SetUseAllPages sets the value of the useAllPages property. +func (o *NanoflowParameterMapping) SetUseAllPages(v bool) { + o.useAllPages.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NanoflowParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "Variable"); err == nil { + o.variable.SetFromDecode(child) + } + if val, err := raw.LookupErr("Widget"); err == nil { + if s, ok := val.StringValueOK(); ok { o.widget.SetFromDecode(s) } + } + o.useAllPages.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// NanoflowSource +// ──────────────────────────────────────────────────────── + +type NanoflowSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + nanoflow *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *NanoflowSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *NanoflowSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// NanoflowQualifiedName returns the value of the nanoflow property. +func (o *NanoflowSource) NanoflowQualifiedName() string { + return o.nanoflow.QualifiedName() +} + +// SetNanoflowQualifiedName sets the value of the nanoflow property. +func (o *NanoflowSource) SetNanoflowQualifiedName(v string) { + o.nanoflow.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *NanoflowSource) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *NanoflowSource) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *NanoflowSource) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NanoflowSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + if val, err := raw.LookupErr("Nanoflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.nanoflow.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// NativeLayoutContent +// ──────────────────────────────────────────────────────── + +type NativeLayoutContent struct { + element.Base + layoutType *property.Enum[string] + widgets *property.PartList[element.Element] + rightHeaderPlaceholder *property.Part[element.Element] + showBottomBar *property.Primitive[bool] + sidebar *property.Primitive[bool] + sidebarWidgets *property.PartList[element.Element] +} + +// LayoutType returns the value of the layoutType property. +func (o *NativeLayoutContent) LayoutType() string { + return o.layoutType.Get() +} + +// SetLayoutType sets the value of the layoutType property. +func (o *NativeLayoutContent) SetLayoutType(v string) { + o.layoutType.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *NativeLayoutContent) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *NativeLayoutContent) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *NativeLayoutContent) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// RightHeaderPlaceholder returns the value of the rightHeaderPlaceholder property. +func (o *NativeLayoutContent) RightHeaderPlaceholder() element.Element { + return o.rightHeaderPlaceholder.Get() +} + +// SetRightHeaderPlaceholder sets the value of the rightHeaderPlaceholder property. +func (o *NativeLayoutContent) SetRightHeaderPlaceholder(v element.Element) { + o.rightHeaderPlaceholder.Set(v) +} + +// ShowBottomBar returns the value of the showBottomBar property. +func (o *NativeLayoutContent) ShowBottomBar() bool { + return o.showBottomBar.Get() +} + +// SetShowBottomBar sets the value of the showBottomBar property. +func (o *NativeLayoutContent) SetShowBottomBar(v bool) { + o.showBottomBar.Set(v) +} + +// Sidebar returns the value of the sidebar property. +func (o *NativeLayoutContent) Sidebar() bool { + return o.sidebar.Get() +} + +// SetSidebar sets the value of the sidebar property. +func (o *NativeLayoutContent) SetSidebar(v bool) { + o.sidebar.Set(v) +} + +// SidebarWidgetsItems returns the value of the sidebarWidgets property. +func (o *NativeLayoutContent) SidebarWidgetsItems() []element.Element { + return o.sidebarWidgets.Items() +} + +// AddSidebarWidgets appends a child element to the sidebarWidgets list. +func (o *NativeLayoutContent) AddSidebarWidgets(v element.Element) { + o.sidebarWidgets.Append(v) +} + +// RemoveSidebarWidgets removes the element at the given index from the sidebarWidgets list. +func (o *NativeLayoutContent) RemoveSidebarWidgets(index int) { + o.sidebarWidgets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NativeLayoutContent) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("LayoutType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.layoutType.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "RightHeaderPlaceholder"); err == nil { + o.rightHeaderPlaceholder.SetFromDecode(child) + } + o.showBottomBar.Init(raw) + o.sidebar.Init(raw) + if children, err := codec.DecodeChildren(raw, "SidebarWidgets"); err == nil { + for _, child := range children { + o.sidebarWidgets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// NavigationList +// ──────────────────────────────────────────────────────── + +type NavigationList struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + items *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *NavigationList) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NavigationList) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *NavigationList) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *NavigationList) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *NavigationList) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *NavigationList) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *NavigationList) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *NavigationList) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *NavigationList) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *NavigationList) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *NavigationList) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *NavigationList) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *NavigationList) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *NavigationList) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ItemsItems returns the value of the items property. +func (o *NavigationList) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *NavigationList) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *NavigationList) RemoveItems(index int) { + o.items.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NavigationList) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// NavigationListItem +// ──────────────────────────────────────────────────────── + +type NavigationListItem struct { + element.Base + action *property.Part[element.Element] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] +} + +// Action returns the value of the action property. +func (o *NavigationListItem) Action() element.Element { + return o.action.Get() +} + +// SetAction sets the value of the action property. +func (o *NavigationListItem) SetAction(v element.Element) { + o.action.Set(v) +} + +// Widget returns the value of the widget property. +func (o *NavigationListItem) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *NavigationListItem) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *NavigationListItem) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *NavigationListItem) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *NavigationListItem) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// Class returns the value of the class property. +func (o *NavigationListItem) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *NavigationListItem) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *NavigationListItem) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *NavigationListItem) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *NavigationListItem) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *NavigationListItem) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *NavigationListItem) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *NavigationListItem) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NavigationListItem) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Action"); err == nil { + o.action.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NavigationSource +// ──────────────────────────────────────────────────────── + +type NavigationSource struct { + element.Base + profileType *property.Enum[string] + navigationProfile *property.ByNameRef[element.Element] +} + +// ProfileType returns the value of the profileType property. +func (o *NavigationSource) ProfileType() string { + return o.profileType.Get() +} + +// SetProfileType sets the value of the profileType property. +func (o *NavigationSource) SetProfileType(v string) { + o.profileType.Set(v) +} + +// NavigationProfileQualifiedName returns the value of the navigationProfile property. +func (o *NavigationSource) NavigationProfileQualifiedName() string { + return o.navigationProfile.QualifiedName() +} + +// SetNavigationProfileQualifiedName sets the value of the navigationProfile property. +func (o *NavigationSource) SetNavigationProfileQualifiedName(v string) { + o.navigationProfile.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NavigationSource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ProfileType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.profileType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("NavigationProfile"); err == nil { + if s, ok := val.StringValueOK(); ok { o.navigationProfile.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// NavigationTree +// ──────────────────────────────────────────────────────── + +type NavigationTree struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + menuSource *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *NavigationTree) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NavigationTree) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *NavigationTree) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *NavigationTree) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *NavigationTree) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *NavigationTree) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *NavigationTree) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *NavigationTree) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *NavigationTree) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *NavigationTree) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// MenuSource returns the value of the menuSource property. +func (o *NavigationTree) MenuSource() element.Element { + return o.menuSource.Get() +} + +// SetMenuSource sets the value of the menuSource property. +func (o *NavigationTree) SetMenuSource(v element.Element) { + o.menuSource.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NavigationTree) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "MenuSource"); err == nil { + o.menuSource.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NewButton +// ──────────────────────────────────────────────────────── + +type NewButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] + entity *property.ByNameRef[element.Element] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + pageSettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *NewButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NewButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *NewButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *NewButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *NewButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *NewButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *NewButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *NewButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *NewButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *NewButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *NewButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *NewButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *NewButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *NewButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *NewButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *NewButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *NewButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *NewButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *NewButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *NewButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *NewButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *NewButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *NewButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *NewButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *NewButton) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *NewButton) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *NewButton) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *NewButton) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *NewButton) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *NewButton) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// PageSettings returns the value of the pageSettings property. +func (o *NewButton) PageSettings() element.Element { + return o.pageSettings.Get() +} + +// SetPageSettings sets the value of the pageSettings property. +func (o *NewButton) SetPageSettings(v element.Element) { + o.pageSettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NewButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "PageSettings"); err == nil { + o.pageSettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NoClientAction +// ──────────────────────────────────────────────────────── + +type NoClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *NoClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *NoClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NoClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OfflineSchema +// ──────────────────────────────────────────────────────── + +type OfflineSchema struct { + element.Base + role *property.ByNameRef[element.Element] + tables *property.Primitive[string] +} + +// RoleQualifiedName returns the value of the role property. +func (o *OfflineSchema) RoleQualifiedName() string { + return o.role.QualifiedName() +} + +// SetRoleQualifiedName sets the value of the role property. +func (o *OfflineSchema) SetRoleQualifiedName(v string) { + o.role.SetQualifiedName(v) +} + +// Tables returns the value of the tables property. +func (o *OfflineSchema) Tables() string { + return o.tables.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OfflineSchema) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Role"); err == nil { + if s, ok := val.StringValueOK(); ok { o.role.SetFromDecode(s) } + } + o.tables.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OfflineSchemaFetchInstruction +// ──────────────────────────────────────────────────────── + +type OfflineSchemaFetchInstruction struct { + element.Base + tableName *property.Primitive[string] + xPath *property.Primitive[string] +} + +// TableName returns the value of the tableName property. +func (o *OfflineSchemaFetchInstruction) TableName() string { + return o.tableName.Get() +} + +// SetTableName sets the value of the tableName property. +func (o *OfflineSchemaFetchInstruction) SetTableName(v string) { + o.tableName.Set(v) +} + +// XPath returns the value of the xPath property. +func (o *OfflineSchemaFetchInstruction) XPath() string { + return o.xPath.Get() +} + +// SetXPath sets the value of the xPath property. +func (o *OfflineSchemaFetchInstruction) SetXPath(v string) { + o.xPath.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OfflineSchemaFetchInstruction) InitFromRaw(raw bson.Raw) { + o.tableName.Init(raw) + o.xPath.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OnClickBehavior +// ──────────────────────────────────────────────────────── + +type OnClickBehavior struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OnClickBehavior) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// OnClickEnlarge +// ──────────────────────────────────────────────────────── + +type OnClickEnlarge struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OnClickEnlarge) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// OnClickMicroflow +// ──────────────────────────────────────────────────────── + +type OnClickMicroflow struct { + element.Base + microflowSettings *property.Part[element.Element] +} + +// MicroflowSettings returns the value of the microflowSettings property. +func (o *OnClickMicroflow) MicroflowSettings() element.Element { + return o.microflowSettings.Get() +} + +// SetMicroflowSettings sets the value of the microflowSettings property. +func (o *OnClickMicroflow) SetMicroflowSettings(v element.Element) { + o.microflowSettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OnClickMicroflow) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "MicroflowSettings"); err == nil { + o.microflowSettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// OnClickNothing +// ──────────────────────────────────────────────────────── + +type OnClickNothing struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OnClickNothing) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// OpenLinkClientAction +// ──────────────────────────────────────────────────────── + +type OpenLinkClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + linkType *property.Enum[string] + address *property.Part[element.Element] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *OpenLinkClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *OpenLinkClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// LinkType returns the value of the linkType property. +func (o *OpenLinkClientAction) LinkType() string { + return o.linkType.Get() +} + +// SetLinkType sets the value of the linkType property. +func (o *OpenLinkClientAction) SetLinkType(v string) { + o.linkType.Set(v) +} + +// Address returns the value of the address property. +func (o *OpenLinkClientAction) Address() element.Element { + return o.address.Get() +} + +// SetAddress sets the value of the address property. +func (o *OpenLinkClientAction) SetAddress(v element.Element) { + o.address.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OpenLinkClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + if val, err := raw.LookupErr("LinkType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.linkType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Address"); err == nil { + o.address.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// OpenUserTaskClientAction +// ──────────────────────────────────────────────────────── + +type OpenUserTaskClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + assignOnOpen *property.Primitive[bool] + openWhenAssigned *property.Primitive[bool] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *OpenUserTaskClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *OpenUserTaskClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// AssignOnOpen returns the value of the assignOnOpen property. +func (o *OpenUserTaskClientAction) AssignOnOpen() bool { + return o.assignOnOpen.Get() +} + +// SetAssignOnOpen sets the value of the assignOnOpen property. +func (o *OpenUserTaskClientAction) SetAssignOnOpen(v bool) { + o.assignOnOpen.Set(v) +} + +// OpenWhenAssigned returns the value of the openWhenAssigned property. +func (o *OpenUserTaskClientAction) OpenWhenAssigned() bool { + return o.openWhenAssigned.Get() +} + +// SetOpenWhenAssigned sets the value of the openWhenAssigned property. +func (o *OpenUserTaskClientAction) SetOpenWhenAssigned(v bool) { + o.openWhenAssigned.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OpenUserTaskClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + o.assignOnOpen.Init(raw) + o.openWhenAssigned.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OpenWorkflowClientAction +// ──────────────────────────────────────────────────────── + +type OpenWorkflowClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + defaultPage *property.ByNameRef[element.Element] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *OpenWorkflowClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *OpenWorkflowClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// DefaultPageQualifiedName returns the value of the defaultPage property. +func (o *OpenWorkflowClientAction) DefaultPageQualifiedName() string { + return o.defaultPage.QualifiedName() +} + +// SetDefaultPageQualifiedName sets the value of the defaultPage property. +func (o *OpenWorkflowClientAction) SetDefaultPageQualifiedName(v string) { + o.defaultPage.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OpenWorkflowClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + if val, err := raw.LookupErr("DefaultPage"); err == nil { + if s, ok := val.StringValueOK(); ok { o.defaultPage.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// OptionDesignPropertyValue +// ──────────────────────────────────────────────────────── + +type OptionDesignPropertyValue struct { + element.Base + option *property.Primitive[string] +} + +// Option returns the value of the option property. +func (o *OptionDesignPropertyValue) Option() string { + return o.option.Get() +} + +// SetOption sets the value of the option property. +func (o *OptionDesignPropertyValue) SetOption(v string) { + o.option.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OptionDesignPropertyValue) InitFromRaw(raw bson.Raw) { + o.option.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OutputMapping +// ──────────────────────────────────────────────────────── + +type OutputMapping struct { + element.Base + sourceVariable *property.Part[element.Element] + expression *property.Primitive[string] + attributeRef *property.Part[element.Element] + sourceAttributeRef *property.Part[element.Element] +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *OutputMapping) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *OutputMapping) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// Expression returns the value of the expression property. +func (o *OutputMapping) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *OutputMapping) SetExpression(v string) { + o.expression.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *OutputMapping) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *OutputMapping) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// SourceAttributeRef returns the value of the sourceAttributeRef property. +func (o *OutputMapping) SourceAttributeRef() element.Element { + return o.sourceAttributeRef.Get() +} + +// SetSourceAttributeRef sets the value of the sourceAttributeRef property. +func (o *OutputMapping) SetSourceAttributeRef(v element.Element) { + o.sourceAttributeRef.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OutputMapping) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceAttributeRef"); err == nil { + o.sourceAttributeRef.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// OverviewPageTemplateType +// ──────────────────────────────────────────────────────── + +type OverviewPageTemplateType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OverviewPageTemplateType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Page +// ──────────────────────────────────────────────────────── + +type Page struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + canvasWidth *property.Primitive[int32] + canvasHeight *property.Primitive[int32] + parameters *property.PartList[element.Element] + layoutCall *property.Part[element.Element] + title *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + allowedRoles *property.ByNameRefList[element.Element] + popupCloseAction *property.Primitive[string] + popupWidth *property.Primitive[int32] + popupHeight *property.Primitive[int32] + popupResizable *property.Primitive[bool] + markAsUsed *property.Primitive[bool] + url *property.Primitive[string] + autofocus *property.Enum[string] + variables *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *Page) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Page) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Page) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Page) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Page) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Page) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Page) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Page) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CanvasWidth returns the value of the canvasWidth property. +func (o *Page) CanvasWidth() int32 { + return o.canvasWidth.Get() +} + +// SetCanvasWidth sets the value of the canvasWidth property. +func (o *Page) SetCanvasWidth(v int32) { + o.canvasWidth.Set(v) +} + +// CanvasHeight returns the value of the canvasHeight property. +func (o *Page) CanvasHeight() int32 { + return o.canvasHeight.Get() +} + +// SetCanvasHeight sets the value of the canvasHeight property. +func (o *Page) SetCanvasHeight(v int32) { + o.canvasHeight.Set(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *Page) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *Page) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *Page) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// LayoutCall returns the value of the layoutCall property. +func (o *Page) LayoutCall() element.Element { + return o.layoutCall.Get() +} + +// SetLayoutCall sets the value of the layoutCall property. +func (o *Page) SetLayoutCall(v element.Element) { + o.layoutCall.Set(v) +} + +// Title returns the value of the title property. +func (o *Page) Title() element.Element { + return o.title.Get() +} + +// SetTitle sets the value of the title property. +func (o *Page) SetTitle(v element.Element) { + o.title.Set(v) +} + +// Class returns the value of the class property. +func (o *Page) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Page) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Page) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Page) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *Page) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *Page) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// AllowedRolesQualifiedNames returns the value of the allowedRoles property. +func (o *Page) AllowedRolesQualifiedNames() []string { + return o.allowedRoles.QualifiedNames() +} + +// SetAllowedRolesQualifiedNames sets the value of the allowedRoles property. +func (o *Page) SetAllowedRolesQualifiedNames(v []string) { + o.allowedRoles.SetQualifiedNames(v) +} + +// AddAllowedRoles appends a child element to the allowedRoles list. +func (o *Page) AddAllowedRoles(v string) { + o.allowedRoles.Append(v) +} + +// PopupCloseAction returns the value of the popupCloseAction property. +func (o *Page) PopupCloseAction() string { + return o.popupCloseAction.Get() +} + +// SetPopupCloseAction sets the value of the popupCloseAction property. +func (o *Page) SetPopupCloseAction(v string) { + o.popupCloseAction.Set(v) +} + +// PopupWidth returns the value of the popupWidth property. +func (o *Page) PopupWidth() int32 { + return o.popupWidth.Get() +} + +// SetPopupWidth sets the value of the popupWidth property. +func (o *Page) SetPopupWidth(v int32) { + o.popupWidth.Set(v) +} + +// PopupHeight returns the value of the popupHeight property. +func (o *Page) PopupHeight() int32 { + return o.popupHeight.Get() +} + +// SetPopupHeight sets the value of the popupHeight property. +func (o *Page) SetPopupHeight(v int32) { + o.popupHeight.Set(v) +} + +// PopupResizable returns the value of the popupResizable property. +func (o *Page) PopupResizable() bool { + return o.popupResizable.Get() +} + +// SetPopupResizable sets the value of the popupResizable property. +func (o *Page) SetPopupResizable(v bool) { + o.popupResizable.Set(v) +} + +// MarkAsUsed returns the value of the markAsUsed property. +func (o *Page) MarkAsUsed() bool { + return o.markAsUsed.Get() +} + +// SetMarkAsUsed sets the value of the markAsUsed property. +func (o *Page) SetMarkAsUsed(v bool) { + o.markAsUsed.Set(v) +} + +// Url returns the value of the url property. +func (o *Page) Url() string { + return o.url.Get() +} + +// SetUrl sets the value of the url property. +func (o *Page) SetUrl(v string) { + o.url.Set(v) +} + +// Autofocus returns the value of the autofocus property. +func (o *Page) Autofocus() string { + return o.autofocus.Get() +} + +// SetAutofocus sets the value of the autofocus property. +func (o *Page) SetAutofocus(v string) { + o.autofocus.Set(v) +} + +// VariablesItems returns the value of the variables property. +func (o *Page) VariablesItems() []element.Element { + return o.variables.Items() +} + +// AddVariables appends a child element to the variables list. +func (o *Page) AddVariables(v element.Element) { + o.variables.Append(v) +} + +// RemoveVariables removes the element at the given index from the variables list. +func (o *Page) RemoveVariables(index int) { + o.variables.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Page) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.canvasWidth.Init(raw) + o.canvasHeight.Init(raw) + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "LayoutCall"); err == nil { + o.layoutCall.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Title"); err == nil { + o.title.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if val, err := raw.LookupErr("AllowedRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.allowedRoles.SetFromDecode(qnames) + } + } + o.popupCloseAction.Init(raw) + o.popupWidth.Init(raw) + o.popupHeight.Init(raw) + o.popupResizable.Init(raw) + o.markAsUsed.Init(raw) + o.url.Init(raw) + if val, err := raw.LookupErr("Autofocus"); err == nil { + if s, ok := val.StringValueOK(); ok { o.autofocus.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Variables"); err == nil { + for _, child := range children { + o.variables.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// PageClientAction +// ──────────────────────────────────────────────────────── + +type PageClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + pageSettings *property.Part[element.Element] + pagesForSpecializations *property.PartList[element.Element] + numberOfPagesToClose *property.Primitive[int32] + numberOfPagesToClose2 *property.Primitive[string] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *PageClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *PageClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// PageSettings returns the value of the pageSettings property. +func (o *PageClientAction) PageSettings() element.Element { + return o.pageSettings.Get() +} + +// SetPageSettings sets the value of the pageSettings property. +func (o *PageClientAction) SetPageSettings(v element.Element) { + o.pageSettings.Set(v) +} + +// PagesForSpecializationsItems returns the value of the pagesForSpecializations property. +func (o *PageClientAction) PagesForSpecializationsItems() []element.Element { + return o.pagesForSpecializations.Items() +} + +// AddPagesForSpecializations appends a child element to the pagesForSpecializations list. +func (o *PageClientAction) AddPagesForSpecializations(v element.Element) { + o.pagesForSpecializations.Append(v) +} + +// RemovePagesForSpecializations removes the element at the given index from the pagesForSpecializations list. +func (o *PageClientAction) RemovePagesForSpecializations(index int) { + o.pagesForSpecializations.Remove(index) +} + +// NumberOfPagesToClose returns the value of the numberOfPagesToClose property. +func (o *PageClientAction) NumberOfPagesToClose() int32 { + return o.numberOfPagesToClose.Get() +} + +// SetNumberOfPagesToClose sets the value of the numberOfPagesToClose property. +func (o *PageClientAction) SetNumberOfPagesToClose(v int32) { + o.numberOfPagesToClose.Set(v) +} + +// NumberOfPagesToClose2 returns the value of the numberOfPagesToClose2 property. +func (o *PageClientAction) NumberOfPagesToClose2() string { + return o.numberOfPagesToClose2.Get() +} + +// SetNumberOfPagesToClose2 sets the value of the numberOfPagesToClose2 property. +func (o *PageClientAction) SetNumberOfPagesToClose2(v string) { + o.numberOfPagesToClose2.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PageClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + if child, err := codec.DecodeChild(raw, "FormSettings"); err == nil { + o.pageSettings.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "PagesForSpecializations"); err == nil { + for _, child := range children { + o.pagesForSpecializations.AppendFromDecode(child) + } + } + o.numberOfPagesToClose.Init(raw) + o.numberOfPagesToClose2.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PageForSpecialization +// ──────────────────────────────────────────────────────── + +type PageForSpecialization struct { + element.Base + entity *property.ByNameRef[element.Element] + pageSettings *property.Part[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *PageForSpecialization) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *PageForSpecialization) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// PageSettings returns the value of the pageSettings property. +func (o *PageForSpecialization) PageSettings() element.Element { + return o.pageSettings.Get() +} + +// SetPageSettings sets the value of the pageSettings property. +func (o *PageForSpecialization) SetPageSettings(v element.Element) { + o.pageSettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PageForSpecialization) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "PageSettings"); err == nil { + o.pageSettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// PageParameter +// ──────────────────────────────────────────────────────── + +type PageParameter struct { + element.Base + name *property.Primitive[string] + parameterType *property.Part[element.Element] + isRequired *property.Primitive[bool] + defaultValue *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *PageParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PageParameter) SetName(v string) { + o.name.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *PageParameter) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *PageParameter) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// IsRequired returns the value of the isRequired property. +func (o *PageParameter) IsRequired() bool { + return o.isRequired.Get() +} + +// SetIsRequired sets the value of the isRequired property. +func (o *PageParameter) SetIsRequired(v bool) { + o.isRequired.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *PageParameter) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *PageParameter) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PageParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } + o.isRequired.Init(raw) + o.defaultValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PageParameterMapping +// ──────────────────────────────────────────────────────── + +type PageParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + variable *property.Part[element.Element] + argument *property.Primitive[string] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *PageParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *PageParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Variable returns the value of the variable property. +func (o *PageParameterMapping) Variable() element.Element { + return o.variable.Get() +} + +// SetVariable sets the value of the variable property. +func (o *PageParameterMapping) SetVariable(v element.Element) { + o.variable.Set(v) +} + +// Argument returns the value of the argument property. +func (o *PageParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *PageParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PageParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Variable"); err == nil { + o.variable.SetFromDecode(child) + } + o.argument.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PagePrimitiveParameterUrlSegment +// ──────────────────────────────────────────────────────── + +type PagePrimitiveParameterUrlSegment struct { + element.Base + pageParameter *property.ByNameRef[element.Element] +} + +// PageParameterQualifiedName returns the value of the pageParameter property. +func (o *PagePrimitiveParameterUrlSegment) PageParameterQualifiedName() string { + return o.pageParameter.QualifiedName() +} + +// SetPageParameterQualifiedName sets the value of the pageParameter property. +func (o *PagePrimitiveParameterUrlSegment) SetPageParameterQualifiedName(v string) { + o.pageParameter.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PagePrimitiveParameterUrlSegment) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("PageParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.pageParameter.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// PageSettings +// ──────────────────────────────────────────────────────── + +type PageSettings struct { + element.Base + page *property.ByNameRef[element.Element] + formTitle *property.Part[element.Element] + titleOverride *property.Part[element.Element] + location *property.Enum[string] + parameterMappings *property.PartList[element.Element] +} + +// PageQualifiedName returns the value of the page property. +func (o *PageSettings) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *PageSettings) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// FormTitle returns the value of the formTitle property. +func (o *PageSettings) FormTitle() element.Element { + return o.formTitle.Get() +} + +// SetFormTitle sets the value of the formTitle property. +func (o *PageSettings) SetFormTitle(v element.Element) { + o.formTitle.Set(v) +} + +// TitleOverride returns the value of the titleOverride property. +func (o *PageSettings) TitleOverride() element.Element { + return o.titleOverride.Get() +} + +// SetTitleOverride sets the value of the titleOverride property. +func (o *PageSettings) SetTitleOverride(v element.Element) { + o.titleOverride.Set(v) +} + +// Location returns the value of the location property. +func (o *PageSettings) Location() string { + return o.location.Get() +} + +// SetLocation sets the value of the location property. +func (o *PageSettings) SetLocation(v string) { + o.location.Set(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *PageSettings) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *PageSettings) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *PageSettings) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PageSettings) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Form"); err == nil { + if s, ok := val.StringValueOK(); ok { o.page.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "FormTitle"); err == nil { + o.formTitle.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TitleOverride"); err == nil { + o.titleOverride.SetFromDecode(child) + } + if val, err := raw.LookupErr("Location"); err == nil { + if s, ok := val.StringValueOK(); ok { o.location.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// PageTemplate +// ──────────────────────────────────────────────────────── + +type PageTemplate struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + canvasWidth *property.Primitive[int32] + canvasHeight *property.Primitive[int32] + displayName *property.Primitive[string] + documentationUrl *property.Primitive[string] + templateCategory *property.Primitive[string] + templateCategoryWeight *property.Primitive[int32] + imageData *property.Primitive[string] + propType *property.Enum[string] + layoutCall *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + templateType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *PageTemplate) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PageTemplate) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PageTemplate) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PageTemplate) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *PageTemplate) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *PageTemplate) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *PageTemplate) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *PageTemplate) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CanvasWidth returns the value of the canvasWidth property. +func (o *PageTemplate) CanvasWidth() int32 { + return o.canvasWidth.Get() +} + +// SetCanvasWidth sets the value of the canvasWidth property. +func (o *PageTemplate) SetCanvasWidth(v int32) { + o.canvasWidth.Set(v) +} + +// CanvasHeight returns the value of the canvasHeight property. +func (o *PageTemplate) CanvasHeight() int32 { + return o.canvasHeight.Get() +} + +// SetCanvasHeight sets the value of the canvasHeight property. +func (o *PageTemplate) SetCanvasHeight(v int32) { + o.canvasHeight.Set(v) +} + +// DisplayName returns the value of the displayName property. +func (o *PageTemplate) DisplayName() string { + return o.displayName.Get() +} + +// SetDisplayName sets the value of the displayName property. +func (o *PageTemplate) SetDisplayName(v string) { + o.displayName.Set(v) +} + +// DocumentationUrl returns the value of the documentationUrl property. +func (o *PageTemplate) DocumentationUrl() string { + return o.documentationUrl.Get() +} + +// SetDocumentationUrl sets the value of the documentationUrl property. +func (o *PageTemplate) SetDocumentationUrl(v string) { + o.documentationUrl.Set(v) +} + +// TemplateCategory returns the value of the templateCategory property. +func (o *PageTemplate) TemplateCategory() string { + return o.templateCategory.Get() +} + +// SetTemplateCategory sets the value of the templateCategory property. +func (o *PageTemplate) SetTemplateCategory(v string) { + o.templateCategory.Set(v) +} + +// TemplateCategoryWeight returns the value of the templateCategoryWeight property. +func (o *PageTemplate) TemplateCategoryWeight() int32 { + return o.templateCategoryWeight.Get() +} + +// SetTemplateCategoryWeight sets the value of the templateCategoryWeight property. +func (o *PageTemplate) SetTemplateCategoryWeight(v int32) { + o.templateCategoryWeight.Set(v) +} + +// ImageData returns the value of the imageData property. +func (o *PageTemplate) ImageData() string { + return o.imageData.Get() +} + +// SetImageData sets the value of the imageData property. +func (o *PageTemplate) SetImageData(v string) { + o.imageData.Set(v) +} + +// Type returns the value of the type property. +func (o *PageTemplate) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *PageTemplate) SetType(v string) { + o.propType.Set(v) +} + +// LayoutCall returns the value of the layoutCall property. +func (o *PageTemplate) LayoutCall() element.Element { + return o.layoutCall.Get() +} + +// SetLayoutCall sets the value of the layoutCall property. +func (o *PageTemplate) SetLayoutCall(v element.Element) { + o.layoutCall.Set(v) +} + +// Class returns the value of the class property. +func (o *PageTemplate) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *PageTemplate) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *PageTemplate) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *PageTemplate) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *PageTemplate) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *PageTemplate) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TemplateType returns the value of the templateType property. +func (o *PageTemplate) TemplateType() element.Element { + return o.templateType.Get() +} + +// SetTemplateType sets the value of the templateType property. +func (o *PageTemplate) SetTemplateType(v element.Element) { + o.templateType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PageTemplate) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.canvasWidth.Init(raw) + o.canvasHeight.Init(raw) + o.displayName.Init(raw) + o.documentationUrl.Init(raw) + o.templateCategory.Init(raw) + o.templateCategoryWeight.Init(raw) + o.imageData.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "LayoutCall"); err == nil { + o.layoutCall.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TemplateType"); err == nil { + o.templateType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// PageVariable +// ──────────────────────────────────────────────────────── + +type PageVariable struct { + element.Base + widget *property.ByNameRef[element.Element] + pageParameter *property.ByNameRef[element.Element] + snippetParameter *property.ByNameRef[element.Element] + localVariable *property.ByNameRef[element.Element] + useAllPages *property.Primitive[bool] + subKey *property.Primitive[string] +} + +// WidgetQualifiedName returns the value of the widget property. +func (o *PageVariable) WidgetQualifiedName() string { + return o.widget.QualifiedName() +} + +// SetWidgetQualifiedName sets the value of the widget property. +func (o *PageVariable) SetWidgetQualifiedName(v string) { + o.widget.SetQualifiedName(v) +} + +// PageParameterQualifiedName returns the value of the pageParameter property. +func (o *PageVariable) PageParameterQualifiedName() string { + return o.pageParameter.QualifiedName() +} + +// SetPageParameterQualifiedName sets the value of the pageParameter property. +func (o *PageVariable) SetPageParameterQualifiedName(v string) { + o.pageParameter.SetQualifiedName(v) +} + +// SnippetParameterQualifiedName returns the value of the snippetParameter property. +func (o *PageVariable) SnippetParameterQualifiedName() string { + return o.snippetParameter.QualifiedName() +} + +// SetSnippetParameterQualifiedName sets the value of the snippetParameter property. +func (o *PageVariable) SetSnippetParameterQualifiedName(v string) { + o.snippetParameter.SetQualifiedName(v) +} + +// LocalVariableQualifiedName returns the value of the localVariable property. +func (o *PageVariable) LocalVariableQualifiedName() string { + return o.localVariable.QualifiedName() +} + +// SetLocalVariableQualifiedName sets the value of the localVariable property. +func (o *PageVariable) SetLocalVariableQualifiedName(v string) { + o.localVariable.SetQualifiedName(v) +} + +// UseAllPages returns the value of the useAllPages property. +func (o *PageVariable) UseAllPages() bool { + return o.useAllPages.Get() +} + +// SetUseAllPages sets the value of the useAllPages property. +func (o *PageVariable) SetUseAllPages(v bool) { + o.useAllPages.Set(v) +} + +// SubKey returns the value of the subKey property. +func (o *PageVariable) SubKey() string { + return o.subKey.Get() +} + +// SetSubKey sets the value of the subKey property. +func (o *PageVariable) SetSubKey(v string) { + o.subKey.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PageVariable) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Widget"); err == nil { + if s, ok := val.StringValueOK(); ok { o.widget.SetFromDecode(s) } + } + if val, err := raw.LookupErr("PageParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.pageParameter.SetFromDecode(s) } + } + if val, err := raw.LookupErr("SnippetParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.snippetParameter.SetFromDecode(s) } + } + if val, err := raw.LookupErr("LocalVariable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.localVariable.SetFromDecode(s) } + } + o.useAllPages.Init(raw) + o.subKey.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ParameterAttributeUrlSegment +// ──────────────────────────────────────────────────────── + +type ParameterAttributeUrlSegment struct { + element.Base + pageParameter *property.ByNameRef[element.Element] + attribute *property.ByNameRef[element.Element] +} + +// PageParameterQualifiedName returns the value of the pageParameter property. +func (o *ParameterAttributeUrlSegment) PageParameterQualifiedName() string { + return o.pageParameter.QualifiedName() +} + +// SetPageParameterQualifiedName sets the value of the pageParameter property. +func (o *ParameterAttributeUrlSegment) SetPageParameterQualifiedName(v string) { + o.pageParameter.SetQualifiedName(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ParameterAttributeUrlSegment) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ParameterAttributeUrlSegment) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ParameterAttributeUrlSegment) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("PageParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.pageParameter.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { o.attribute.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ParameterIdUrlSegment +// ──────────────────────────────────────────────────────── + +type ParameterIdUrlSegment struct { + element.Base + pageParameter *property.ByNameRef[element.Element] +} + +// PageParameterQualifiedName returns the value of the pageParameter property. +func (o *ParameterIdUrlSegment) PageParameterQualifiedName() string { + return o.pageParameter.QualifiedName() +} + +// SetPageParameterQualifiedName sets the value of the pageParameter property. +func (o *ParameterIdUrlSegment) SetPageParameterQualifiedName(v string) { + o.pageParameter.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ParameterIdUrlSegment) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("PageParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.pageParameter.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// PasswordTextBox +// ──────────────────────────────────────────────────────── + +type PasswordTextBox struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + label *property.Part[element.Element] + labelWidth *property.Primitive[int32] + placeholder *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *PasswordTextBox) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PasswordTextBox) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *PasswordTextBox) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *PasswordTextBox) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *PasswordTextBox) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *PasswordTextBox) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *PasswordTextBox) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *PasswordTextBox) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *PasswordTextBox) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *PasswordTextBox) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// Label returns the value of the label property. +func (o *PasswordTextBox) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *PasswordTextBox) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelWidth returns the value of the labelWidth property. +func (o *PasswordTextBox) LabelWidth() int32 { + return o.labelWidth.Get() +} + +// SetLabelWidth sets the value of the labelWidth property. +func (o *PasswordTextBox) SetLabelWidth(v int32) { + o.labelWidth.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *PasswordTextBox) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *PasswordTextBox) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PasswordTextBox) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + o.labelWidth.Init(raw) + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Placeholder +// ──────────────────────────────────────────────────────── + +type Placeholder struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *Placeholder) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Placeholder) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *Placeholder) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Placeholder) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Placeholder) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Placeholder) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *Placeholder) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *Placeholder) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *Placeholder) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *Placeholder) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Placeholder) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RadioButtonGroup +// ──────────────────────────────────────────────────────── + +type RadioButtonGroup struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + required *property.Primitive[bool] + requiredMessage *property.Part[element.Element] + validation *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onEnterMicroflowSettings *property.Part[element.Element] + onLeaveMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + onEnterAction *property.Part[element.Element] + onLeaveAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + ariaRequired *property.Primitive[bool] + renderHorizontal *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *RadioButtonGroup) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RadioButtonGroup) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *RadioButtonGroup) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *RadioButtonGroup) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *RadioButtonGroup) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *RadioButtonGroup) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *RadioButtonGroup) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *RadioButtonGroup) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *RadioButtonGroup) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *RadioButtonGroup) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *RadioButtonGroup) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *RadioButtonGroup) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *RadioButtonGroup) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *RadioButtonGroup) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *RadioButtonGroup) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *RadioButtonGroup) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *RadioButtonGroup) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *RadioButtonGroup) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *RadioButtonGroup) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *RadioButtonGroup) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *RadioButtonGroup) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *RadioButtonGroup) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *RadioButtonGroup) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *RadioButtonGroup) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *RadioButtonGroup) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *RadioButtonGroup) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *RadioButtonGroup) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *RadioButtonGroup) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *RadioButtonGroup) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *RadioButtonGroup) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// Required returns the value of the required property. +func (o *RadioButtonGroup) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *RadioButtonGroup) SetRequired(v bool) { + o.required.Set(v) +} + +// RequiredMessage returns the value of the requiredMessage property. +func (o *RadioButtonGroup) RequiredMessage() element.Element { + return o.requiredMessage.Get() +} + +// SetRequiredMessage sets the value of the requiredMessage property. +func (o *RadioButtonGroup) SetRequiredMessage(v element.Element) { + o.requiredMessage.Set(v) +} + +// Validation returns the value of the validation property. +func (o *RadioButtonGroup) Validation() element.Element { + return o.validation.Get() +} + +// SetValidation sets the value of the validation property. +func (o *RadioButtonGroup) SetValidation(v element.Element) { + o.validation.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *RadioButtonGroup) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *RadioButtonGroup) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnEnterMicroflowSettings returns the value of the onEnterMicroflowSettings property. +func (o *RadioButtonGroup) OnEnterMicroflowSettings() element.Element { + return o.onEnterMicroflowSettings.Get() +} + +// SetOnEnterMicroflowSettings sets the value of the onEnterMicroflowSettings property. +func (o *RadioButtonGroup) SetOnEnterMicroflowSettings(v element.Element) { + o.onEnterMicroflowSettings.Set(v) +} + +// OnLeaveMicroflowSettings returns the value of the onLeaveMicroflowSettings property. +func (o *RadioButtonGroup) OnLeaveMicroflowSettings() element.Element { + return o.onLeaveMicroflowSettings.Get() +} + +// SetOnLeaveMicroflowSettings sets the value of the onLeaveMicroflowSettings property. +func (o *RadioButtonGroup) SetOnLeaveMicroflowSettings(v element.Element) { + o.onLeaveMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *RadioButtonGroup) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *RadioButtonGroup) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// OnEnterAction returns the value of the onEnterAction property. +func (o *RadioButtonGroup) OnEnterAction() element.Element { + return o.onEnterAction.Get() +} + +// SetOnEnterAction sets the value of the onEnterAction property. +func (o *RadioButtonGroup) SetOnEnterAction(v element.Element) { + o.onEnterAction.Set(v) +} + +// OnLeaveAction returns the value of the onLeaveAction property. +func (o *RadioButtonGroup) OnLeaveAction() element.Element { + return o.onLeaveAction.Get() +} + +// SetOnLeaveAction sets the value of the onLeaveAction property. +func (o *RadioButtonGroup) SetOnLeaveAction(v element.Element) { + o.onLeaveAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *RadioButtonGroup) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *RadioButtonGroup) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// AriaRequired returns the value of the ariaRequired property. +func (o *RadioButtonGroup) AriaRequired() bool { + return o.ariaRequired.Get() +} + +// SetAriaRequired sets the value of the ariaRequired property. +func (o *RadioButtonGroup) SetAriaRequired(v bool) { + o.ariaRequired.Set(v) +} + +// RenderHorizontal returns the value of the renderHorizontal property. +func (o *RadioButtonGroup) RenderHorizontal() bool { + return o.renderHorizontal.Get() +} + +// SetRenderHorizontal sets the value of the renderHorizontal property. +func (o *RadioButtonGroup) SetRenderHorizontal(v bool) { + o.renderHorizontal.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RadioButtonGroup) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + o.required.Init(raw) + if child, err := codec.DecodeChild(raw, "RequiredMessage"); err == nil { + o.requiredMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Validation"); err == nil { + o.validation.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterMicroflowSettings"); err == nil { + o.onEnterMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveMicroflowSettings"); err == nil { + o.onLeaveMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterAction"); err == nil { + o.onEnterAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveAction"); err == nil { + o.onLeaveAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.ariaRequired.Init(raw) + o.renderHorizontal.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RangeSearchField +// ──────────────────────────────────────────────────────── + +type RangeSearchField struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + placeholder *property.Part[element.Element] + customDateFormat *property.Primitive[string] + propType *property.Enum[string] + defaultValue *property.Primitive[string] + lowerBound *property.Primitive[string] + upperBound *property.Primitive[string] + lowerBoundRef *property.Part[element.Element] + upperBoundRef *property.Part[element.Element] + includeLower *property.Primitive[bool] + includeUpper *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *RangeSearchField) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RangeSearchField) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *RangeSearchField) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *RangeSearchField) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *RangeSearchField) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *RangeSearchField) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// CustomDateFormat returns the value of the customDateFormat property. +func (o *RangeSearchField) CustomDateFormat() string { + return o.customDateFormat.Get() +} + +// SetCustomDateFormat sets the value of the customDateFormat property. +func (o *RangeSearchField) SetCustomDateFormat(v string) { + o.customDateFormat.Set(v) +} + +// Type returns the value of the type property. +func (o *RangeSearchField) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *RangeSearchField) SetType(v string) { + o.propType.Set(v) +} + +// DefaultValue returns the value of the defaultValue property. +func (o *RangeSearchField) DefaultValue() string { + return o.defaultValue.Get() +} + +// SetDefaultValue sets the value of the defaultValue property. +func (o *RangeSearchField) SetDefaultValue(v string) { + o.defaultValue.Set(v) +} + +// LowerBound returns the value of the lowerBound property. +func (o *RangeSearchField) LowerBound() string { + return o.lowerBound.Get() +} + +// SetLowerBound sets the value of the lowerBound property. +func (o *RangeSearchField) SetLowerBound(v string) { + o.lowerBound.Set(v) +} + +// UpperBound returns the value of the upperBound property. +func (o *RangeSearchField) UpperBound() string { + return o.upperBound.Get() +} + +// SetUpperBound sets the value of the upperBound property. +func (o *RangeSearchField) SetUpperBound(v string) { + o.upperBound.Set(v) +} + +// LowerBoundRef returns the value of the lowerBoundRef property. +func (o *RangeSearchField) LowerBoundRef() element.Element { + return o.lowerBoundRef.Get() +} + +// SetLowerBoundRef sets the value of the lowerBoundRef property. +func (o *RangeSearchField) SetLowerBoundRef(v element.Element) { + o.lowerBoundRef.Set(v) +} + +// UpperBoundRef returns the value of the upperBoundRef property. +func (o *RangeSearchField) UpperBoundRef() element.Element { + return o.upperBoundRef.Get() +} + +// SetUpperBoundRef sets the value of the upperBoundRef property. +func (o *RangeSearchField) SetUpperBoundRef(v element.Element) { + o.upperBoundRef.Set(v) +} + +// IncludeLower returns the value of the includeLower property. +func (o *RangeSearchField) IncludeLower() bool { + return o.includeLower.Get() +} + +// SetIncludeLower sets the value of the includeLower property. +func (o *RangeSearchField) SetIncludeLower(v bool) { + o.includeLower.Set(v) +} + +// IncludeUpper returns the value of the includeUpper property. +func (o *RangeSearchField) IncludeUpper() bool { + return o.includeUpper.Get() +} + +// SetIncludeUpper sets the value of the includeUpper property. +func (o *RangeSearchField) SetIncludeUpper(v bool) { + o.includeUpper.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RangeSearchField) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } + o.customDateFormat.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.defaultValue.Init(raw) + o.lowerBound.Init(raw) + o.upperBound.Init(raw) + if child, err := codec.DecodeChild(raw, "LowerBoundRef"); err == nil { + o.lowerBoundRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "UpperBoundRef"); err == nil { + o.upperBoundRef.SetFromDecode(child) + } + o.includeLower.Init(raw) + o.includeUpper.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ReferenceSelector +// ──────────────────────────────────────────────────────── + +type ReferenceSelector struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + selectorSource *property.Part[element.Element] + selectPageSettings *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + required *property.Primitive[bool] + requiredMessage *property.Part[element.Element] + validation *property.Part[element.Element] + renderMode *property.Enum[string] + gotoPageSettings *property.Part[element.Element] + formattingInfo *property.Part[element.Element] + emptyOptionCaption *property.Part[element.Element] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *ReferenceSelector) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ReferenceSelector) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ReferenceSelector) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ReferenceSelector) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ReferenceSelector) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ReferenceSelector) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ReferenceSelector) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ReferenceSelector) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ReferenceSelector) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ReferenceSelector) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *ReferenceSelector) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *ReferenceSelector) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *ReferenceSelector) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *ReferenceSelector) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *ReferenceSelector) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *ReferenceSelector) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *ReferenceSelector) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *ReferenceSelector) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *ReferenceSelector) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *ReferenceSelector) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *ReferenceSelector) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *ReferenceSelector) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *ReferenceSelector) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *ReferenceSelector) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *ReferenceSelector) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *ReferenceSelector) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *ReferenceSelector) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *ReferenceSelector) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *ReferenceSelector) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *ReferenceSelector) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// SelectorSource returns the value of the selectorSource property. +func (o *ReferenceSelector) SelectorSource() element.Element { + return o.selectorSource.Get() +} + +// SetSelectorSource sets the value of the selectorSource property. +func (o *ReferenceSelector) SetSelectorSource(v element.Element) { + o.selectorSource.Set(v) +} + +// SelectPageSettings returns the value of the selectPageSettings property. +func (o *ReferenceSelector) SelectPageSettings() element.Element { + return o.selectPageSettings.Get() +} + +// SetSelectPageSettings sets the value of the selectPageSettings property. +func (o *ReferenceSelector) SetSelectPageSettings(v element.Element) { + o.selectPageSettings.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *ReferenceSelector) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *ReferenceSelector) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *ReferenceSelector) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *ReferenceSelector) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ReferenceSelector) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ReferenceSelector) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// Required returns the value of the required property. +func (o *ReferenceSelector) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *ReferenceSelector) SetRequired(v bool) { + o.required.Set(v) +} + +// RequiredMessage returns the value of the requiredMessage property. +func (o *ReferenceSelector) RequiredMessage() element.Element { + return o.requiredMessage.Get() +} + +// SetRequiredMessage sets the value of the requiredMessage property. +func (o *ReferenceSelector) SetRequiredMessage(v element.Element) { + o.requiredMessage.Set(v) +} + +// Validation returns the value of the validation property. +func (o *ReferenceSelector) Validation() element.Element { + return o.validation.Get() +} + +// SetValidation sets the value of the validation property. +func (o *ReferenceSelector) SetValidation(v element.Element) { + o.validation.Set(v) +} + +// RenderMode returns the value of the renderMode property. +func (o *ReferenceSelector) RenderMode() string { + return o.renderMode.Get() +} + +// SetRenderMode sets the value of the renderMode property. +func (o *ReferenceSelector) SetRenderMode(v string) { + o.renderMode.Set(v) +} + +// GotoPageSettings returns the value of the gotoPageSettings property. +func (o *ReferenceSelector) GotoPageSettings() element.Element { + return o.gotoPageSettings.Get() +} + +// SetGotoPageSettings sets the value of the gotoPageSettings property. +func (o *ReferenceSelector) SetGotoPageSettings(v element.Element) { + o.gotoPageSettings.Set(v) +} + +// FormattingInfo returns the value of the formattingInfo property. +func (o *ReferenceSelector) FormattingInfo() element.Element { + return o.formattingInfo.Get() +} + +// SetFormattingInfo sets the value of the formattingInfo property. +func (o *ReferenceSelector) SetFormattingInfo(v element.Element) { + o.formattingInfo.Set(v) +} + +// EmptyOptionCaption returns the value of the emptyOptionCaption property. +func (o *ReferenceSelector) EmptyOptionCaption() element.Element { + return o.emptyOptionCaption.Get() +} + +// SetEmptyOptionCaption sets the value of the emptyOptionCaption property. +func (o *ReferenceSelector) SetEmptyOptionCaption(v element.Element) { + o.emptyOptionCaption.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *ReferenceSelector) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *ReferenceSelector) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReferenceSelector) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "SelectorSource"); err == nil { + o.selectorSource.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SelectPageSettings"); err == nil { + o.selectPageSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.required.Init(raw) + if child, err := codec.DecodeChild(raw, "RequiredMessage"); err == nil { + o.requiredMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Validation"); err == nil { + o.validation.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderMode.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "GotoPageSettings"); err == nil { + o.gotoPageSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "FormattingInfo"); err == nil { + o.formattingInfo.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "EmptyOptionCaption"); err == nil { + o.emptyOptionCaption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ReferenceSetSelector +// ──────────────────────────────────────────────────────── + +type ReferenceSetSelector struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + dataSource *property.Part[element.Element] + isControlBarVisible *property.Primitive[bool] + isPagingEnabled *property.Primitive[bool] + showPagingBar *property.Enum[string] + selectionMode *property.Enum[string] + selectFirst *property.Primitive[bool] + defaultButtonTrigger *property.Enum[string] + refreshTime *property.Primitive[int32] + controlBar *property.Part[element.Element] + columns *property.PartList[element.Element] + numberOfRows *property.Primitive[int32] + showEmptyRows *property.Primitive[bool] + widthUnit *property.Enum[string] + tooltipPage *property.ByNameRef[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + constrainedBy *property.Primitive[string] + constrainedByRefs *property.PartList[element.Element] + xPathConstraint *property.Primitive[string] + removeAllFromContext *property.Primitive[bool] + removeFromContextEntities *property.ByNameRefList[element.Element] +} + +// Name returns the value of the name property. +func (o *ReferenceSetSelector) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ReferenceSetSelector) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ReferenceSetSelector) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ReferenceSetSelector) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ReferenceSetSelector) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ReferenceSetSelector) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ReferenceSetSelector) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ReferenceSetSelector) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ReferenceSetSelector) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ReferenceSetSelector) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *ReferenceSetSelector) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *ReferenceSetSelector) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *ReferenceSetSelector) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *ReferenceSetSelector) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// DataSource returns the value of the dataSource property. +func (o *ReferenceSetSelector) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *ReferenceSetSelector) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// IsControlBarVisible returns the value of the isControlBarVisible property. +func (o *ReferenceSetSelector) IsControlBarVisible() bool { + return o.isControlBarVisible.Get() +} + +// SetIsControlBarVisible sets the value of the isControlBarVisible property. +func (o *ReferenceSetSelector) SetIsControlBarVisible(v bool) { + o.isControlBarVisible.Set(v) +} + +// IsPagingEnabled returns the value of the isPagingEnabled property. +func (o *ReferenceSetSelector) IsPagingEnabled() bool { + return o.isPagingEnabled.Get() +} + +// SetIsPagingEnabled sets the value of the isPagingEnabled property. +func (o *ReferenceSetSelector) SetIsPagingEnabled(v bool) { + o.isPagingEnabled.Set(v) +} + +// ShowPagingBar returns the value of the showPagingBar property. +func (o *ReferenceSetSelector) ShowPagingBar() string { + return o.showPagingBar.Get() +} + +// SetShowPagingBar sets the value of the showPagingBar property. +func (o *ReferenceSetSelector) SetShowPagingBar(v string) { + o.showPagingBar.Set(v) +} + +// SelectionMode returns the value of the selectionMode property. +func (o *ReferenceSetSelector) SelectionMode() string { + return o.selectionMode.Get() +} + +// SetSelectionMode sets the value of the selectionMode property. +func (o *ReferenceSetSelector) SetSelectionMode(v string) { + o.selectionMode.Set(v) +} + +// SelectFirst returns the value of the selectFirst property. +func (o *ReferenceSetSelector) SelectFirst() bool { + return o.selectFirst.Get() +} + +// SetSelectFirst sets the value of the selectFirst property. +func (o *ReferenceSetSelector) SetSelectFirst(v bool) { + o.selectFirst.Set(v) +} + +// DefaultButtonTrigger returns the value of the defaultButtonTrigger property. +func (o *ReferenceSetSelector) DefaultButtonTrigger() string { + return o.defaultButtonTrigger.Get() +} + +// SetDefaultButtonTrigger sets the value of the defaultButtonTrigger property. +func (o *ReferenceSetSelector) SetDefaultButtonTrigger(v string) { + o.defaultButtonTrigger.Set(v) +} + +// RefreshTime returns the value of the refreshTime property. +func (o *ReferenceSetSelector) RefreshTime() int32 { + return o.refreshTime.Get() +} + +// SetRefreshTime sets the value of the refreshTime property. +func (o *ReferenceSetSelector) SetRefreshTime(v int32) { + o.refreshTime.Set(v) +} + +// ControlBar returns the value of the controlBar property. +func (o *ReferenceSetSelector) ControlBar() element.Element { + return o.controlBar.Get() +} + +// SetControlBar sets the value of the controlBar property. +func (o *ReferenceSetSelector) SetControlBar(v element.Element) { + o.controlBar.Set(v) +} + +// ColumnsItems returns the value of the columns property. +func (o *ReferenceSetSelector) ColumnsItems() []element.Element { + return o.columns.Items() +} + +// AddColumns appends a child element to the columns list. +func (o *ReferenceSetSelector) AddColumns(v element.Element) { + o.columns.Append(v) +} + +// RemoveColumns removes the element at the given index from the columns list. +func (o *ReferenceSetSelector) RemoveColumns(index int) { + o.columns.Remove(index) +} + +// NumberOfRows returns the value of the numberOfRows property. +func (o *ReferenceSetSelector) NumberOfRows() int32 { + return o.numberOfRows.Get() +} + +// SetNumberOfRows sets the value of the numberOfRows property. +func (o *ReferenceSetSelector) SetNumberOfRows(v int32) { + o.numberOfRows.Set(v) +} + +// ShowEmptyRows returns the value of the showEmptyRows property. +func (o *ReferenceSetSelector) ShowEmptyRows() bool { + return o.showEmptyRows.Get() +} + +// SetShowEmptyRows sets the value of the showEmptyRows property. +func (o *ReferenceSetSelector) SetShowEmptyRows(v bool) { + o.showEmptyRows.Set(v) +} + +// WidthUnit returns the value of the widthUnit property. +func (o *ReferenceSetSelector) WidthUnit() string { + return o.widthUnit.Get() +} + +// SetWidthUnit sets the value of the widthUnit property. +func (o *ReferenceSetSelector) SetWidthUnit(v string) { + o.widthUnit.Set(v) +} + +// TooltipPageQualifiedName returns the value of the tooltipPage property. +func (o *ReferenceSetSelector) TooltipPageQualifiedName() string { + return o.tooltipPage.QualifiedName() +} + +// SetTooltipPageQualifiedName sets the value of the tooltipPage property. +func (o *ReferenceSetSelector) SetTooltipPageQualifiedName(v string) { + o.tooltipPage.SetQualifiedName(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *ReferenceSetSelector) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *ReferenceSetSelector) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *ReferenceSetSelector) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *ReferenceSetSelector) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// ConstrainedBy returns the value of the constrainedBy property. +func (o *ReferenceSetSelector) ConstrainedBy() string { + return o.constrainedBy.Get() +} + +// ConstrainedByRefsItems returns the value of the constrainedByRefs property. +func (o *ReferenceSetSelector) ConstrainedByRefsItems() []element.Element { + return o.constrainedByRefs.Items() +} + +// AddConstrainedByRefs appends a child element to the constrainedByRefs list. +func (o *ReferenceSetSelector) AddConstrainedByRefs(v element.Element) { + o.constrainedByRefs.Append(v) +} + +// RemoveConstrainedByRefs removes the element at the given index from the constrainedByRefs list. +func (o *ReferenceSetSelector) RemoveConstrainedByRefs(index int) { + o.constrainedByRefs.Remove(index) +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *ReferenceSetSelector) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *ReferenceSetSelector) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// RemoveAllFromContext returns the value of the removeAllFromContext property. +func (o *ReferenceSetSelector) RemoveAllFromContext() bool { + return o.removeAllFromContext.Get() +} + +// SetRemoveAllFromContext sets the value of the removeAllFromContext property. +func (o *ReferenceSetSelector) SetRemoveAllFromContext(v bool) { + o.removeAllFromContext.Set(v) +} + +// RemoveFromContextEntitiesQualifiedNames returns the value of the removeFromContextEntities property. +func (o *ReferenceSetSelector) RemoveFromContextEntitiesQualifiedNames() []string { + return o.removeFromContextEntities.QualifiedNames() +} + +// SetRemoveFromContextEntitiesQualifiedNames sets the value of the removeFromContextEntities property. +func (o *ReferenceSetSelector) SetRemoveFromContextEntitiesQualifiedNames(v []string) { + o.removeFromContextEntities.SetQualifiedNames(v) +} + +// AddRemoveFromContextEntities appends a child element to the removeFromContextEntities list. +func (o *ReferenceSetSelector) AddRemoveFromContextEntities(v string) { + o.removeFromContextEntities.Append(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReferenceSetSelector) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } + o.isControlBarVisible.Init(raw) + o.isPagingEnabled.Init(raw) + if val, err := raw.LookupErr("ShowPagingBar"); err == nil { + if s, ok := val.StringValueOK(); ok { o.showPagingBar.SetFromDecode(s) } + } + if val, err := raw.LookupErr("SelectionMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.selectionMode.SetFromDecode(s) } + } + o.selectFirst.Init(raw) + if val, err := raw.LookupErr("DefaultButtonTrigger"); err == nil { + if s, ok := val.StringValueOK(); ok { o.defaultButtonTrigger.SetFromDecode(s) } + } + o.refreshTime.Init(raw) + if child, err := codec.DecodeChild(raw, "ControlBar"); err == nil { + o.controlBar.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Columns"); err == nil { + for _, child := range children { + o.columns.AppendFromDecode(child) + } + } + o.numberOfRows.Init(raw) + o.showEmptyRows.Init(raw) + if val, err := raw.LookupErr("WidthUnit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.widthUnit.SetFromDecode(s) } + } + if val, err := raw.LookupErr("TooltipPage"); err == nil { + if s, ok := val.StringValueOK(); ok { o.tooltipPage.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + o.constrainedBy.Init(raw) + if children, err := codec.DecodeChildren(raw, "ConstrainedByRefs"); err == nil { + for _, child := range children { + o.constrainedByRefs.AppendFromDecode(child) + } + } + o.xPathConstraint.Init(raw) + o.removeAllFromContext.Init(raw) + if val, err := raw.LookupErr("RemoveFromContextEntities"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.removeFromContextEntities.SetFromDecode(qnames) + } + } +} + +// ──────────────────────────────────────────────────────── +// ReferenceSetSource +// ──────────────────────────────────────────────────────── + +type ReferenceSetSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + sortBar *property.Part[element.Element] + searchBar *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *ReferenceSetSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *ReferenceSetSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *ReferenceSetSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *ReferenceSetSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *ReferenceSetSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *ReferenceSetSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ReferenceSetSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ReferenceSetSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// SortBar returns the value of the sortBar property. +func (o *ReferenceSetSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *ReferenceSetSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// SearchBar returns the value of the searchBar property. +func (o *ReferenceSetSource) SearchBar() element.Element { + return o.searchBar.Get() +} + +// SetSearchBar sets the value of the searchBar property. +func (o *ReferenceSetSource) SetSearchBar(v element.Element) { + o.searchBar.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReferenceSetSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SearchBar"); err == nil { + o.searchBar.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// RegularPageTemplateType +// ──────────────────────────────────────────────────────── + +type RegularPageTemplateType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RegularPageTemplateType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// RetrievalQuery +// ──────────────────────────────────────────────────────── + +type RetrievalQuery struct { + element.Base + queryId *property.Primitive[string] + allowedUserRoles *property.ByNameRefList[element.Element] + allowedUserRoleSets *property.PartList[element.Element] + xPath *property.Primitive[string] + microflow *property.ByNameRef[element.Element] + entityPath *property.Primitive[string] + pageName *property.Primitive[string] + widgetName *property.Primitive[string] + usedAssociations *property.Primitive[string] + usedAttributes *property.Primitive[string] + schemaId *property.Primitive[string] + parameters *property.PartList[element.Element] +} + +// QueryId returns the value of the queryId property. +func (o *RetrievalQuery) QueryId() string { + return o.queryId.Get() +} + +// SetQueryId sets the value of the queryId property. +func (o *RetrievalQuery) SetQueryId(v string) { + o.queryId.Set(v) +} + +// AllowedUserRolesQualifiedNames returns the value of the allowedUserRoles property. +func (o *RetrievalQuery) AllowedUserRolesQualifiedNames() []string { + return o.allowedUserRoles.QualifiedNames() +} + +// SetAllowedUserRolesQualifiedNames sets the value of the allowedUserRoles property. +func (o *RetrievalQuery) SetAllowedUserRolesQualifiedNames(v []string) { + o.allowedUserRoles.SetQualifiedNames(v) +} + +// AddAllowedUserRoles appends a child element to the allowedUserRoles list. +func (o *RetrievalQuery) AddAllowedUserRoles(v string) { + o.allowedUserRoles.Append(v) +} + +// AllowedUserRoleSetsItems returns the value of the allowedUserRoleSets property. +func (o *RetrievalQuery) AllowedUserRoleSetsItems() []element.Element { + return o.allowedUserRoleSets.Items() +} + +// AddAllowedUserRoleSets appends a child element to the allowedUserRoleSets list. +func (o *RetrievalQuery) AddAllowedUserRoleSets(v element.Element) { + o.allowedUserRoleSets.Append(v) +} + +// RemoveAllowedUserRoleSets removes the element at the given index from the allowedUserRoleSets list. +func (o *RetrievalQuery) RemoveAllowedUserRoleSets(index int) { + o.allowedUserRoleSets.Remove(index) +} + +// XPath returns the value of the xPath property. +func (o *RetrievalQuery) XPath() string { + return o.xPath.Get() +} + +// SetXPath sets the value of the xPath property. +func (o *RetrievalQuery) SetXPath(v string) { + o.xPath.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *RetrievalQuery) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *RetrievalQuery) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *RetrievalQuery) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *RetrievalQuery) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// PageName returns the value of the pageName property. +func (o *RetrievalQuery) PageName() string { + return o.pageName.Get() +} + +// SetPageName sets the value of the pageName property. +func (o *RetrievalQuery) SetPageName(v string) { + o.pageName.Set(v) +} + +// WidgetName returns the value of the widgetName property. +func (o *RetrievalQuery) WidgetName() string { + return o.widgetName.Get() +} + +// SetWidgetName sets the value of the widgetName property. +func (o *RetrievalQuery) SetWidgetName(v string) { + o.widgetName.Set(v) +} + +// UsedAssociations returns the value of the usedAssociations property. +func (o *RetrievalQuery) UsedAssociations() string { + return o.usedAssociations.Get() +} + +// UsedAttributes returns the value of the usedAttributes property. +func (o *RetrievalQuery) UsedAttributes() string { + return o.usedAttributes.Get() +} + +// SchemaId returns the value of the schemaId property. +func (o *RetrievalQuery) SchemaId() string { + return o.schemaId.Get() +} + +// SetSchemaId sets the value of the schemaId property. +func (o *RetrievalQuery) SetSchemaId(v string) { + o.schemaId.Set(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *RetrievalQuery) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *RetrievalQuery) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *RetrievalQuery) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RetrievalQuery) InitFromRaw(raw bson.Raw) { + o.queryId.Init(raw) + if val, err := raw.LookupErr("AllowedUserRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.allowedUserRoles.SetFromDecode(qnames) + } + } + if children, err := codec.DecodeChildren(raw, "AllowedUserRoleSets"); err == nil { + for _, child := range children { + o.allowedUserRoleSets.AppendFromDecode(child) + } + } + o.xPath.Init(raw) + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } + o.entityPath.Init(raw) + o.pageName.Init(raw) + o.widgetName.Init(raw) + o.usedAssociations.Init(raw) + o.usedAttributes.Init(raw) + o.schemaId.Init(raw) + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// RetrievalQueryParameter +// ──────────────────────────────────────────────────────── + +type RetrievalQueryParameter struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + types *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *RetrievalQueryParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RetrievalQueryParameter) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *RetrievalQueryParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *RetrievalQueryParameter) SetType(v string) { + o.propType.Set(v) +} + +// Types returns the value of the types property. +func (o *RetrievalQueryParameter) Types() string { + return o.types.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RetrievalQueryParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + o.types.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RetrievalSchema +// ──────────────────────────────────────────────────────── + +type RetrievalSchema struct { + element.Base + usedAttributes *property.Primitive[string] + usedAssociations *property.Primitive[string] + widgetName *property.Primitive[string] + entity *property.Primitive[string] +} + +// UsedAttributes returns the value of the usedAttributes property. +func (o *RetrievalSchema) UsedAttributes() string { + return o.usedAttributes.Get() +} + +// UsedAssociations returns the value of the usedAssociations property. +func (o *RetrievalSchema) UsedAssociations() string { + return o.usedAssociations.Get() +} + +// WidgetName returns the value of the widgetName property. +func (o *RetrievalSchema) WidgetName() string { + return o.widgetName.Get() +} + +// SetWidgetName sets the value of the widgetName property. +func (o *RetrievalSchema) SetWidgetName(v string) { + o.widgetName.Set(v) +} + +// Entity returns the value of the entity property. +func (o *RetrievalSchema) Entity() string { + return o.entity.Get() +} + +// SetEntity sets the value of the entity property. +func (o *RetrievalSchema) SetEntity(v string) { + o.entity.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RetrievalSchema) InitFromRaw(raw bson.Raw) { + o.usedAttributes.Init(raw) + o.usedAssociations.Init(raw) + o.widgetName.Init(raw) + o.entity.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RuntimeOperation +// ──────────────────────────────────────────────────────── + +type RuntimeOperation struct { + element.Base + operationId *property.Primitive[string] + parameters *property.PartList[element.Element] + constants *property.PartList[element.Element] + operationType *property.Primitive[string] + operationName *property.Primitive[string] + allowedUserRoles *property.ByNameRefList[element.Element] + allowedUserRoleSets *property.PartList[element.Element] +} + +// OperationId returns the value of the operationId property. +func (o *RuntimeOperation) OperationId() string { + return o.operationId.Get() +} + +// SetOperationId sets the value of the operationId property. +func (o *RuntimeOperation) SetOperationId(v string) { + o.operationId.Set(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *RuntimeOperation) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *RuntimeOperation) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *RuntimeOperation) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// ConstantsItems returns the value of the constants property. +func (o *RuntimeOperation) ConstantsItems() []element.Element { + return o.constants.Items() +} + +// AddConstants appends a child element to the constants list. +func (o *RuntimeOperation) AddConstants(v element.Element) { + o.constants.Append(v) +} + +// RemoveConstants removes the element at the given index from the constants list. +func (o *RuntimeOperation) RemoveConstants(index int) { + o.constants.Remove(index) +} + +// OperationType returns the value of the operationType property. +func (o *RuntimeOperation) OperationType() string { + return o.operationType.Get() +} + +// SetOperationType sets the value of the operationType property. +func (o *RuntimeOperation) SetOperationType(v string) { + o.operationType.Set(v) +} + +// OperationName returns the value of the operationName property. +func (o *RuntimeOperation) OperationName() string { + return o.operationName.Get() +} + +// SetOperationName sets the value of the operationName property. +func (o *RuntimeOperation) SetOperationName(v string) { + o.operationName.Set(v) +} + +// AllowedUserRolesQualifiedNames returns the value of the allowedUserRoles property. +func (o *RuntimeOperation) AllowedUserRolesQualifiedNames() []string { + return o.allowedUserRoles.QualifiedNames() +} + +// SetAllowedUserRolesQualifiedNames sets the value of the allowedUserRoles property. +func (o *RuntimeOperation) SetAllowedUserRolesQualifiedNames(v []string) { + o.allowedUserRoles.SetQualifiedNames(v) +} + +// AddAllowedUserRoles appends a child element to the allowedUserRoles list. +func (o *RuntimeOperation) AddAllowedUserRoles(v string) { + o.allowedUserRoles.Append(v) +} + +// AllowedUserRoleSetsItems returns the value of the allowedUserRoleSets property. +func (o *RuntimeOperation) AllowedUserRoleSetsItems() []element.Element { + return o.allowedUserRoleSets.Items() +} + +// AddAllowedUserRoleSets appends a child element to the allowedUserRoleSets list. +func (o *RuntimeOperation) AddAllowedUserRoleSets(v element.Element) { + o.allowedUserRoleSets.Append(v) +} + +// RemoveAllowedUserRoleSets removes the element at the given index from the allowedUserRoleSets list. +func (o *RuntimeOperation) RemoveAllowedUserRoleSets(index int) { + o.allowedUserRoleSets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RuntimeOperation) InitFromRaw(raw bson.Raw) { + o.operationId.Init(raw) + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Constants"); err == nil { + for _, child := range children { + o.constants.AppendFromDecode(child) + } + } + o.operationType.Init(raw) + o.operationName.Init(raw) + if val, err := raw.LookupErr("AllowedUserRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.allowedUserRoles.SetFromDecode(qnames) + } + } + if children, err := codec.DecodeChildren(raw, "AllowedUserRoleSets"); err == nil { + for _, child := range children { + o.allowedUserRoleSets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// SaveButton +// ──────────────────────────────────────────────────────── + +type SaveButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] + syncAutomatically *property.Primitive[bool] + closePage *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *SaveButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SaveButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *SaveButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *SaveButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *SaveButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *SaveButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *SaveButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *SaveButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *SaveButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *SaveButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *SaveButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *SaveButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *SaveButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *SaveButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *SaveButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *SaveButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *SaveButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *SaveButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *SaveButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *SaveButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *SaveButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *SaveButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *SaveButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *SaveButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// SyncAutomatically returns the value of the syncAutomatically property. +func (o *SaveButton) SyncAutomatically() bool { + return o.syncAutomatically.Get() +} + +// SetSyncAutomatically sets the value of the syncAutomatically property. +func (o *SaveButton) SetSyncAutomatically(v bool) { + o.syncAutomatically.Set(v) +} + +// ClosePage returns the value of the closePage property. +func (o *SaveButton) ClosePage() bool { + return o.closePage.Get() +} + +// SetClosePage sets the value of the closePage property. +func (o *SaveButton) SetClosePage(v bool) { + o.closePage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SaveButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + o.syncAutomatically.Init(raw) + o.closePage.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SaveChangesClientAction +// ──────────────────────────────────────────────────────── + +type SaveChangesClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + syncAutomatically *property.Primitive[bool] + closePage *property.Primitive[bool] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *SaveChangesClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *SaveChangesClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// SyncAutomatically returns the value of the syncAutomatically property. +func (o *SaveChangesClientAction) SyncAutomatically() bool { + return o.syncAutomatically.Get() +} + +// SetSyncAutomatically sets the value of the syncAutomatically property. +func (o *SaveChangesClientAction) SetSyncAutomatically(v bool) { + o.syncAutomatically.Set(v) +} + +// ClosePage returns the value of the closePage property. +func (o *SaveChangesClientAction) ClosePage() bool { + return o.closePage.Get() +} + +// SetClosePage sets the value of the closePage property. +func (o *SaveChangesClientAction) SetClosePage(v bool) { + o.closePage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SaveChangesClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + o.syncAutomatically.Init(raw) + o.closePage.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ScrollContainer +// ──────────────────────────────────────────────────────── + +type ScrollContainer struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + center *property.Part[element.Element] + left *property.Part[element.Element] + right *property.Part[element.Element] + top *property.Part[element.Element] + bottom *property.Part[element.Element] + layoutMode *property.Enum[string] + widthMode *property.Enum[string] + width *property.Primitive[int32] + alignment *property.Enum[string] + scrollBehavior *property.Enum[string] + nativeHideScrollbars *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *ScrollContainer) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ScrollContainer) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ScrollContainer) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ScrollContainer) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ScrollContainer) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ScrollContainer) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ScrollContainer) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ScrollContainer) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ScrollContainer) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ScrollContainer) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// Center returns the value of the center property. +func (o *ScrollContainer) Center() element.Element { + return o.center.Get() +} + +// SetCenter sets the value of the center property. +func (o *ScrollContainer) SetCenter(v element.Element) { + o.center.Set(v) +} + +// Left returns the value of the left property. +func (o *ScrollContainer) Left() element.Element { + return o.left.Get() +} + +// SetLeft sets the value of the left property. +func (o *ScrollContainer) SetLeft(v element.Element) { + o.left.Set(v) +} + +// Right returns the value of the right property. +func (o *ScrollContainer) Right() element.Element { + return o.right.Get() +} + +// SetRight sets the value of the right property. +func (o *ScrollContainer) SetRight(v element.Element) { + o.right.Set(v) +} + +// Top returns the value of the top property. +func (o *ScrollContainer) Top() element.Element { + return o.top.Get() +} + +// SetTop sets the value of the top property. +func (o *ScrollContainer) SetTop(v element.Element) { + o.top.Set(v) +} + +// Bottom returns the value of the bottom property. +func (o *ScrollContainer) Bottom() element.Element { + return o.bottom.Get() +} + +// SetBottom sets the value of the bottom property. +func (o *ScrollContainer) SetBottom(v element.Element) { + o.bottom.Set(v) +} + +// LayoutMode returns the value of the layoutMode property. +func (o *ScrollContainer) LayoutMode() string { + return o.layoutMode.Get() +} + +// SetLayoutMode sets the value of the layoutMode property. +func (o *ScrollContainer) SetLayoutMode(v string) { + o.layoutMode.Set(v) +} + +// WidthMode returns the value of the widthMode property. +func (o *ScrollContainer) WidthMode() string { + return o.widthMode.Get() +} + +// SetWidthMode sets the value of the widthMode property. +func (o *ScrollContainer) SetWidthMode(v string) { + o.widthMode.Set(v) +} + +// Width returns the value of the width property. +func (o *ScrollContainer) Width() int32 { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *ScrollContainer) SetWidth(v int32) { + o.width.Set(v) +} + +// Alignment returns the value of the alignment property. +func (o *ScrollContainer) Alignment() string { + return o.alignment.Get() +} + +// SetAlignment sets the value of the alignment property. +func (o *ScrollContainer) SetAlignment(v string) { + o.alignment.Set(v) +} + +// ScrollBehavior returns the value of the scrollBehavior property. +func (o *ScrollContainer) ScrollBehavior() string { + return o.scrollBehavior.Get() +} + +// SetScrollBehavior sets the value of the scrollBehavior property. +func (o *ScrollContainer) SetScrollBehavior(v string) { + o.scrollBehavior.Set(v) +} + +// NativeHideScrollbars returns the value of the nativeHideScrollbars property. +func (o *ScrollContainer) NativeHideScrollbars() bool { + return o.nativeHideScrollbars.Get() +} + +// SetNativeHideScrollbars sets the value of the nativeHideScrollbars property. +func (o *ScrollContainer) SetNativeHideScrollbars(v bool) { + o.nativeHideScrollbars.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ScrollContainer) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "Center"); err == nil { + o.center.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Left"); err == nil { + o.left.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Right"); err == nil { + o.right.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Top"); err == nil { + o.top.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Bottom"); err == nil { + o.bottom.SetFromDecode(child) + } + if val, err := raw.LookupErr("LayoutMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.layoutMode.SetFromDecode(s) } + } + if val, err := raw.LookupErr("WidthMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.widthMode.SetFromDecode(s) } + } + o.width.Init(raw) + if val, err := raw.LookupErr("Alignment"); err == nil { + if s, ok := val.StringValueOK(); ok { o.alignment.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ScrollBehavior"); err == nil { + if s, ok := val.StringValueOK(); ok { o.scrollBehavior.SetFromDecode(s) } + } + o.nativeHideScrollbars.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ScrollContainerRegion +// ──────────────────────────────────────────────────────── + +type ScrollContainerRegion struct { + element.Base + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + sizeMode *property.Enum[string] + size *property.Primitive[int32] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + toggleMode *property.Enum[string] +} + +// Widget returns the value of the widget property. +func (o *ScrollContainerRegion) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *ScrollContainerRegion) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *ScrollContainerRegion) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *ScrollContainerRegion) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *ScrollContainerRegion) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// SizeMode returns the value of the sizeMode property. +func (o *ScrollContainerRegion) SizeMode() string { + return o.sizeMode.Get() +} + +// SetSizeMode sets the value of the sizeMode property. +func (o *ScrollContainerRegion) SetSizeMode(v string) { + o.sizeMode.Set(v) +} + +// Size returns the value of the size property. +func (o *ScrollContainerRegion) Size() int32 { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *ScrollContainerRegion) SetSize(v int32) { + o.size.Set(v) +} + +// Class returns the value of the class property. +func (o *ScrollContainerRegion) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ScrollContainerRegion) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ScrollContainerRegion) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ScrollContainerRegion) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ScrollContainerRegion) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ScrollContainerRegion) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ToggleMode returns the value of the toggleMode property. +func (o *ScrollContainerRegion) ToggleMode() string { + return o.toggleMode.Get() +} + +// SetToggleMode sets the value of the toggleMode property. +func (o *ScrollContainerRegion) SetToggleMode(v string) { + o.toggleMode.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ScrollContainerRegion) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("SizeMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.sizeMode.SetFromDecode(s) } + } + o.size.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if val, err := raw.LookupErr("ToggleMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.toggleMode.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// SearchBar +// ──────────────────────────────────────────────────────── + +type SearchBar struct { + element.Base + items *property.PartList[element.Element] + propType *property.Enum[string] + waitForSearch *property.Primitive[bool] +} + +// ItemsItems returns the value of the items property. +func (o *SearchBar) ItemsItems() []element.Element { + return o.items.Items() +} + +// AddItems appends a child element to the items list. +func (o *SearchBar) AddItems(v element.Element) { + o.items.Append(v) +} + +// RemoveItems removes the element at the given index from the items list. +func (o *SearchBar) RemoveItems(index int) { + o.items.Remove(index) +} + +// Type returns the value of the type property. +func (o *SearchBar) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *SearchBar) SetType(v string) { + o.propType.Set(v) +} + +// WaitForSearch returns the value of the waitForSearch property. +func (o *SearchBar) WaitForSearch() bool { + return o.waitForSearch.Get() +} + +// SetWaitForSearch sets the value of the waitForSearch property. +func (o *SearchBar) SetWaitForSearch(v bool) { + o.waitForSearch.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SearchBar) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Items"); err == nil { + for _, child := range children { + o.items.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + o.waitForSearch.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SelectButton +// ──────────────────────────────────────────────────────── + +type SelectButton struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *SelectButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SelectButton) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *SelectButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *SelectButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *SelectButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *SelectButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *SelectButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *SelectButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// Class returns the value of the class property. +func (o *SelectButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *SelectButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *SelectButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *SelectButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *SelectButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *SelectButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *SelectButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *SelectButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *SelectButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *SelectButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SelectButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// SelectPageTemplateType +// ──────────────────────────────────────────────────────── + +type SelectPageTemplateType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SelectPageTemplateType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// SelectorSource +// ──────────────────────────────────────────────────────── + +type SelectorSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SelectorSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// SelectorDatabaseSource +// ──────────────────────────────────────────────────────── + +type SelectorDatabaseSource struct { + element.Base + databaseConstraints *property.PartList[element.Element] + sortBar *property.Part[element.Element] +} + +// DatabaseConstraintsItems returns the value of the databaseConstraints property. +func (o *SelectorDatabaseSource) DatabaseConstraintsItems() []element.Element { + return o.databaseConstraints.Items() +} + +// AddDatabaseConstraints appends a child element to the databaseConstraints list. +func (o *SelectorDatabaseSource) AddDatabaseConstraints(v element.Element) { + o.databaseConstraints.Append(v) +} + +// RemoveDatabaseConstraints removes the element at the given index from the databaseConstraints list. +func (o *SelectorDatabaseSource) RemoveDatabaseConstraints(index int) { + o.databaseConstraints.Remove(index) +} + +// SortBar returns the value of the sortBar property. +func (o *SelectorDatabaseSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *SelectorDatabaseSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SelectorDatabaseSource) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "DatabaseConstraints"); err == nil { + for _, child := range children { + o.databaseConstraints.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// SelectorMicroflowSource +// ──────────────────────────────────────────────────────── + +type SelectorMicroflowSource struct { + element.Base + dataSourceMicroflowSettings *property.Part[element.Element] +} + +// DataSourceMicroflowSettings returns the value of the dataSourceMicroflowSettings property. +func (o *SelectorMicroflowSource) DataSourceMicroflowSettings() element.Element { + return o.dataSourceMicroflowSettings.Get() +} + +// SetDataSourceMicroflowSettings sets the value of the dataSourceMicroflowSettings property. +func (o *SelectorMicroflowSource) SetDataSourceMicroflowSettings(v element.Element) { + o.dataSourceMicroflowSettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SelectorMicroflowSource) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "DataSourceMicroflowSettings"); err == nil { + o.dataSourceMicroflowSettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// SelectorXPathSource +// ──────────────────────────────────────────────────────── + +type SelectorXPathSource struct { + element.Base + sortBar *property.Part[element.Element] + xPathConstraint *property.Primitive[string] + constrainedBy *property.Primitive[string] + constrainedByRefs *property.PartList[element.Element] + applyContext *property.Primitive[bool] + removeAllFromContext *property.Primitive[bool] + removeFromContextEntities *property.ByNameRefList[element.Element] +} + +// SortBar returns the value of the sortBar property. +func (o *SelectorXPathSource) SortBar() element.Element { + return o.sortBar.Get() +} + +// SetSortBar sets the value of the sortBar property. +func (o *SelectorXPathSource) SetSortBar(v element.Element) { + o.sortBar.Set(v) +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *SelectorXPathSource) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *SelectorXPathSource) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// ConstrainedBy returns the value of the constrainedBy property. +func (o *SelectorXPathSource) ConstrainedBy() string { + return o.constrainedBy.Get() +} + +// ConstrainedByRefsItems returns the value of the constrainedByRefs property. +func (o *SelectorXPathSource) ConstrainedByRefsItems() []element.Element { + return o.constrainedByRefs.Items() +} + +// AddConstrainedByRefs appends a child element to the constrainedByRefs list. +func (o *SelectorXPathSource) AddConstrainedByRefs(v element.Element) { + o.constrainedByRefs.Append(v) +} + +// RemoveConstrainedByRefs removes the element at the given index from the constrainedByRefs list. +func (o *SelectorXPathSource) RemoveConstrainedByRefs(index int) { + o.constrainedByRefs.Remove(index) +} + +// ApplyContext returns the value of the applyContext property. +func (o *SelectorXPathSource) ApplyContext() bool { + return o.applyContext.Get() +} + +// SetApplyContext sets the value of the applyContext property. +func (o *SelectorXPathSource) SetApplyContext(v bool) { + o.applyContext.Set(v) +} + +// RemoveAllFromContext returns the value of the removeAllFromContext property. +func (o *SelectorXPathSource) RemoveAllFromContext() bool { + return o.removeAllFromContext.Get() +} + +// SetRemoveAllFromContext sets the value of the removeAllFromContext property. +func (o *SelectorXPathSource) SetRemoveAllFromContext(v bool) { + o.removeAllFromContext.Set(v) +} + +// RemoveFromContextEntitiesQualifiedNames returns the value of the removeFromContextEntities property. +func (o *SelectorXPathSource) RemoveFromContextEntitiesQualifiedNames() []string { + return o.removeFromContextEntities.QualifiedNames() +} + +// SetRemoveFromContextEntitiesQualifiedNames sets the value of the removeFromContextEntities property. +func (o *SelectorXPathSource) SetRemoveFromContextEntitiesQualifiedNames(v []string) { + o.removeFromContextEntities.SetQualifiedNames(v) +} + +// AddRemoveFromContextEntities appends a child element to the removeFromContextEntities list. +func (o *SelectorXPathSource) AddRemoveFromContextEntities(v string) { + o.removeFromContextEntities.Append(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SelectorXPathSource) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "SortBar"); err == nil { + o.sortBar.SetFromDecode(child) + } + o.xPathConstraint.Init(raw) + o.constrainedBy.Init(raw) + if children, err := codec.DecodeChildren(raw, "ConstrainedByRefs"); err == nil { + for _, child := range children { + o.constrainedByRefs.AppendFromDecode(child) + } + } + o.applyContext.Init(raw) + o.removeAllFromContext.Init(raw) + if val, err := raw.LookupErr("RemoveFromContextEntities"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.removeFromContextEntities.SetFromDecode(qnames) + } + } +} + +// ──────────────────────────────────────────────────────── +// SetTaskOutcomeClientAction +// ──────────────────────────────────────────────────────── + +type SetTaskOutcomeClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] + outcome *property.ByNameRef[element.Element] + outcomeValue *property.Primitive[string] + closePage *property.Primitive[bool] + commit *property.Primitive[bool] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *SetTaskOutcomeClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *SetTaskOutcomeClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// OutcomeQualifiedName returns the value of the outcome property. +func (o *SetTaskOutcomeClientAction) OutcomeQualifiedName() string { + return o.outcome.QualifiedName() +} + +// SetOutcomeQualifiedName sets the value of the outcome property. +func (o *SetTaskOutcomeClientAction) SetOutcomeQualifiedName(v string) { + o.outcome.SetQualifiedName(v) +} + +// OutcomeValue returns the value of the outcomeValue property. +func (o *SetTaskOutcomeClientAction) OutcomeValue() string { + return o.outcomeValue.Get() +} + +// SetOutcomeValue sets the value of the outcomeValue property. +func (o *SetTaskOutcomeClientAction) SetOutcomeValue(v string) { + o.outcomeValue.Set(v) +} + +// ClosePage returns the value of the closePage property. +func (o *SetTaskOutcomeClientAction) ClosePage() bool { + return o.closePage.Get() +} + +// SetClosePage sets the value of the closePage property. +func (o *SetTaskOutcomeClientAction) SetClosePage(v bool) { + o.closePage.Set(v) +} + +// Commit returns the value of the commit property. +func (o *SetTaskOutcomeClientAction) Commit() bool { + return o.commit.Get() +} + +// SetCommit sets the value of the commit property. +func (o *SetTaskOutcomeClientAction) SetCommit(v bool) { + o.commit.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SetTaskOutcomeClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) + if val, err := raw.LookupErr("Outcome"); err == nil { + if s, ok := val.StringValueOK(); ok { o.outcome.SetFromDecode(s) } + } + o.outcomeValue.Init(raw) + o.closePage.Init(raw) + o.commit.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SidebarToggleButton +// ──────────────────────────────────────────────────────── + +type SidebarToggleButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] + region *property.Enum[string] + mode *property.Enum[string] + initiallyOpen *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *SidebarToggleButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SidebarToggleButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *SidebarToggleButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *SidebarToggleButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *SidebarToggleButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *SidebarToggleButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *SidebarToggleButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *SidebarToggleButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *SidebarToggleButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *SidebarToggleButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *SidebarToggleButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *SidebarToggleButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *SidebarToggleButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *SidebarToggleButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *SidebarToggleButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *SidebarToggleButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *SidebarToggleButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *SidebarToggleButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *SidebarToggleButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *SidebarToggleButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *SidebarToggleButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *SidebarToggleButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *SidebarToggleButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *SidebarToggleButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// Region returns the value of the region property. +func (o *SidebarToggleButton) Region() string { + return o.region.Get() +} + +// SetRegion sets the value of the region property. +func (o *SidebarToggleButton) SetRegion(v string) { + o.region.Set(v) +} + +// Mode returns the value of the mode property. +func (o *SidebarToggleButton) Mode() string { + return o.mode.Get() +} + +// SetMode sets the value of the mode property. +func (o *SidebarToggleButton) SetMode(v string) { + o.mode.Set(v) +} + +// InitiallyOpen returns the value of the initiallyOpen property. +func (o *SidebarToggleButton) InitiallyOpen() bool { + return o.initiallyOpen.Get() +} + +// SetInitiallyOpen sets the value of the initiallyOpen property. +func (o *SidebarToggleButton) SetInitiallyOpen(v bool) { + o.initiallyOpen.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SidebarToggleButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Region"); err == nil { + if s, ok := val.StringValueOK(); ok { o.region.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Mode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.mode.SetFromDecode(s) } + } + o.initiallyOpen.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SignOutClientAction +// ──────────────────────────────────────────────────────── + +type SignOutClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *SignOutClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *SignOutClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SignOutClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SimpleMenuBar +// ──────────────────────────────────────────────────────── + +type SimpleMenuBar struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + menuSource *property.Part[element.Element] + orientation *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *SimpleMenuBar) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SimpleMenuBar) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *SimpleMenuBar) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *SimpleMenuBar) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *SimpleMenuBar) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *SimpleMenuBar) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *SimpleMenuBar) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *SimpleMenuBar) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *SimpleMenuBar) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *SimpleMenuBar) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// MenuSource returns the value of the menuSource property. +func (o *SimpleMenuBar) MenuSource() element.Element { + return o.menuSource.Get() +} + +// SetMenuSource sets the value of the menuSource property. +func (o *SimpleMenuBar) SetMenuSource(v element.Element) { + o.menuSource.Set(v) +} + +// Orientation returns the value of the orientation property. +func (o *SimpleMenuBar) Orientation() string { + return o.orientation.Get() +} + +// SetOrientation sets the value of the orientation property. +func (o *SimpleMenuBar) SetOrientation(v string) { + o.orientation.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SimpleMenuBar) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "MenuSource"); err == nil { + o.menuSource.SetFromDecode(child) + } + if val, err := raw.LookupErr("Orientation"); err == nil { + if s, ok := val.StringValueOK(); ok { o.orientation.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// Snippet +// ──────────────────────────────────────────────────────── + +type Snippet struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + canvasWidth *property.Primitive[int32] + canvasHeight *property.Primitive[int32] + entity *property.ByNameRef[element.Element] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + propType *property.Enum[string] + parameters *property.PartList[element.Element] + variables *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *Snippet) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Snippet) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Snippet) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Snippet) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Snippet) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Snippet) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Snippet) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Snippet) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// CanvasWidth returns the value of the canvasWidth property. +func (o *Snippet) CanvasWidth() int32 { + return o.canvasWidth.Get() +} + +// SetCanvasWidth sets the value of the canvasWidth property. +func (o *Snippet) SetCanvasWidth(v int32) { + o.canvasWidth.Set(v) +} + +// CanvasHeight returns the value of the canvasHeight property. +func (o *Snippet) CanvasHeight() int32 { + return o.canvasHeight.Get() +} + +// SetCanvasHeight sets the value of the canvasHeight property. +func (o *Snippet) SetCanvasHeight(v int32) { + o.canvasHeight.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *Snippet) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *Snippet) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// Widget returns the value of the widget property. +func (o *Snippet) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *Snippet) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *Snippet) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *Snippet) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *Snippet) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// Type returns the value of the type property. +func (o *Snippet) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *Snippet) SetType(v string) { + o.propType.Set(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *Snippet) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *Snippet) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *Snippet) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// VariablesItems returns the value of the variables property. +func (o *Snippet) VariablesItems() []element.Element { + return o.variables.Items() +} + +// AddVariables appends a child element to the variables list. +func (o *Snippet) AddVariables(v element.Element) { + o.variables.Append(v) +} + +// RemoveVariables removes the element at the given index from the variables list. +func (o *Snippet) RemoveVariables(index int) { + o.variables.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Snippet) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.canvasWidth.Init(raw) + o.canvasHeight.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { o.propType.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Variables"); err == nil { + for _, child := range children { + o.variables.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// SnippetCall +// ──────────────────────────────────────────────────────── + +type SnippetCall struct { + element.Base + snippet *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] +} + +// SnippetQualifiedName returns the value of the snippet property. +func (o *SnippetCall) SnippetQualifiedName() string { + return o.snippet.QualifiedName() +} + +// SetSnippetQualifiedName sets the value of the snippet property. +func (o *SnippetCall) SetSnippetQualifiedName(v string) { + o.snippet.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *SnippetCall) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *SnippetCall) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *SnippetCall) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SnippetCall) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Form"); err == nil { + if s, ok := val.StringValueOK(); ok { o.snippet.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// SnippetCallWidget +// ──────────────────────────────────────────────────────── + +type SnippetCallWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + snippetCall *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *SnippetCallWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SnippetCallWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *SnippetCallWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *SnippetCallWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *SnippetCallWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *SnippetCallWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *SnippetCallWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *SnippetCallWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *SnippetCallWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *SnippetCallWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// SnippetCall returns the value of the snippetCall property. +func (o *SnippetCallWidget) SnippetCall() element.Element { + return o.snippetCall.Get() +} + +// SetSnippetCall sets the value of the snippetCall property. +func (o *SnippetCallWidget) SetSnippetCall(v element.Element) { + o.snippetCall.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SnippetCallWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "FormCall"); err == nil { + o.snippetCall.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// SnippetParameter +// ──────────────────────────────────────────────────────── + +type SnippetParameter struct { + element.Base + name *property.Primitive[string] + parameterType *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *SnippetParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SnippetParameter) SetName(v string) { + o.name.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *SnippetParameter) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *SnippetParameter) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SnippetParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// SnippetParameterMapping +// ──────────────────────────────────────────────────────── + +type SnippetParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + variable *property.Part[element.Element] + argument *property.Primitive[string] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *SnippetParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *SnippetParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Variable returns the value of the variable property. +func (o *SnippetParameterMapping) Variable() element.Element { + return o.variable.Get() +} + +// SetVariable sets the value of the variable property. +func (o *SnippetParameterMapping) SetVariable(v element.Element) { + o.variable.Set(v) +} + +// Argument returns the value of the argument property. +func (o *SnippetParameterMapping) Argument() string { + return o.argument.Get() +} + +// SetArgument sets the value of the argument property. +func (o *SnippetParameterMapping) SetArgument(v string) { + o.argument.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SnippetParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Variable"); err == nil { + o.variable.SetFromDecode(child) + } + o.argument.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// StaticImageViewer +// ──────────────────────────────────────────────────────── + +type StaticImageViewer struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + image *property.ByNameRef[element.Element] + widthUnit *property.Enum[string] + heightUnit *property.Enum[string] + width *property.Primitive[int32] + height *property.Primitive[int32] + clickAction *property.Part[element.Element] + responsive *property.Primitive[bool] + alternativeText *property.Part[element.Element] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *StaticImageViewer) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *StaticImageViewer) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *StaticImageViewer) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *StaticImageViewer) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *StaticImageViewer) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *StaticImageViewer) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *StaticImageViewer) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *StaticImageViewer) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *StaticImageViewer) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *StaticImageViewer) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *StaticImageViewer) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *StaticImageViewer) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *StaticImageViewer) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *StaticImageViewer) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ImageQualifiedName returns the value of the image property. +func (o *StaticImageViewer) ImageQualifiedName() string { + return o.image.QualifiedName() +} + +// SetImageQualifiedName sets the value of the image property. +func (o *StaticImageViewer) SetImageQualifiedName(v string) { + o.image.SetQualifiedName(v) +} + +// WidthUnit returns the value of the widthUnit property. +func (o *StaticImageViewer) WidthUnit() string { + return o.widthUnit.Get() +} + +// SetWidthUnit sets the value of the widthUnit property. +func (o *StaticImageViewer) SetWidthUnit(v string) { + o.widthUnit.Set(v) +} + +// HeightUnit returns the value of the heightUnit property. +func (o *StaticImageViewer) HeightUnit() string { + return o.heightUnit.Get() +} + +// SetHeightUnit sets the value of the heightUnit property. +func (o *StaticImageViewer) SetHeightUnit(v string) { + o.heightUnit.Set(v) +} + +// Width returns the value of the width property. +func (o *StaticImageViewer) Width() int32 { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *StaticImageViewer) SetWidth(v int32) { + o.width.Set(v) +} + +// Height returns the value of the height property. +func (o *StaticImageViewer) Height() int32 { + return o.height.Get() +} + +// SetHeight sets the value of the height property. +func (o *StaticImageViewer) SetHeight(v int32) { + o.height.Set(v) +} + +// ClickAction returns the value of the clickAction property. +func (o *StaticImageViewer) ClickAction() element.Element { + return o.clickAction.Get() +} + +// SetClickAction sets the value of the clickAction property. +func (o *StaticImageViewer) SetClickAction(v element.Element) { + o.clickAction.Set(v) +} + +// Responsive returns the value of the responsive property. +func (o *StaticImageViewer) Responsive() bool { + return o.responsive.Get() +} + +// SetResponsive sets the value of the responsive property. +func (o *StaticImageViewer) SetResponsive(v bool) { + o.responsive.Set(v) +} + +// AlternativeText returns the value of the alternativeText property. +func (o *StaticImageViewer) AlternativeText() element.Element { + return o.alternativeText.Get() +} + +// SetAlternativeText sets the value of the alternativeText property. +func (o *StaticImageViewer) SetAlternativeText(v element.Element) { + o.alternativeText.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *StaticImageViewer) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *StaticImageViewer) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StaticImageViewer) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Image"); err == nil { + if s, ok := val.StringValueOK(); ok { o.image.SetFromDecode(s) } + } + if val, err := raw.LookupErr("WidthUnit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.widthUnit.SetFromDecode(s) } + } + if val, err := raw.LookupErr("HeightUnit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.heightUnit.SetFromDecode(s) } + } + o.width.Init(raw) + o.height.Init(raw) + if child, err := codec.DecodeChild(raw, "ClickAction"); err == nil { + o.clickAction.SetFromDecode(child) + } + o.responsive.Init(raw) + if child, err := codec.DecodeChild(raw, "AlternativeText"); err == nil { + o.alternativeText.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// StaticOrDynamicString +// ──────────────────────────────────────────────────────── + +type StaticOrDynamicString struct { + element.Base + isDynamic *property.Primitive[bool] + value *property.Primitive[string] + attribute *property.Primitive[string] + attributeRef *property.Part[element.Element] +} + +// IsDynamic returns the value of the isDynamic property. +func (o *StaticOrDynamicString) IsDynamic() bool { + return o.isDynamic.Get() +} + +// SetIsDynamic sets the value of the isDynamic property. +func (o *StaticOrDynamicString) SetIsDynamic(v bool) { + o.isDynamic.Set(v) +} + +// Value returns the value of the value property. +func (o *StaticOrDynamicString) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *StaticOrDynamicString) SetValue(v string) { + o.value.Set(v) +} + +// Attribute returns the value of the attribute property. +func (o *StaticOrDynamicString) Attribute() string { + return o.attribute.Get() +} + +// SetAttribute sets the value of the attribute property. +func (o *StaticOrDynamicString) SetAttribute(v string) { + o.attribute.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *StaticOrDynamicString) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *StaticOrDynamicString) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StaticOrDynamicString) InitFromRaw(raw bson.Raw) { + o.isDynamic.Init(raw) + o.value.Init(raw) + o.attribute.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// UrlSegment +// ──────────────────────────────────────────────────────── + +type UrlSegment struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UrlSegment) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// StaticUrlSegment +// ──────────────────────────────────────────────────────── + +type StaticUrlSegment struct { + element.Base + segment *property.Primitive[string] +} + +// Segment returns the value of the segment property. +func (o *StaticUrlSegment) Segment() string { + return o.segment.Get() +} + +// SetSegment sets the value of the segment property. +func (o *StaticUrlSegment) SetSegment(v string) { + o.segment.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StaticUrlSegment) InitFromRaw(raw bson.Raw) { + o.segment.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SyncButton +// ──────────────────────────────────────────────────────── + +type SyncButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + caption *property.Part[element.Element] + tooltip *property.Part[element.Element] + icon *property.Part[element.Element] + renderType *property.Enum[string] + buttonStyle *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *SyncButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SyncButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *SyncButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *SyncButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *SyncButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *SyncButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *SyncButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *SyncButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *SyncButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *SyncButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *SyncButton) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *SyncButton) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *SyncButton) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *SyncButton) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// Caption returns the value of the caption property. +func (o *SyncButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *SyncButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Tooltip returns the value of the tooltip property. +func (o *SyncButton) Tooltip() element.Element { + return o.tooltip.Get() +} + +// SetTooltip sets the value of the tooltip property. +func (o *SyncButton) SetTooltip(v element.Element) { + o.tooltip.Set(v) +} + +// Icon returns the value of the icon property. +func (o *SyncButton) Icon() element.Element { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *SyncButton) SetIcon(v element.Element) { + o.icon.Set(v) +} + +// RenderType returns the value of the renderType property. +func (o *SyncButton) RenderType() string { + return o.renderType.Get() +} + +// SetRenderType sets the value of the renderType property. +func (o *SyncButton) SetRenderType(v string) { + o.renderType.Set(v) +} + +// ButtonStyle returns the value of the buttonStyle property. +func (o *SyncButton) ButtonStyle() string { + return o.buttonStyle.Get() +} + +// SetButtonStyle sets the value of the buttonStyle property. +func (o *SyncButton) SetButtonStyle(v string) { + o.buttonStyle.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SyncButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Tooltip"); err == nil { + o.tooltip.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Icon"); err == nil { + o.icon.SetFromDecode(child) + } + if val, err := raw.LookupErr("RenderType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.renderType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ButtonStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.buttonStyle.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// SyncClientAction +// ──────────────────────────────────────────────────────── + +type SyncClientAction struct { + element.Base + disabledDuringExecution *property.Primitive[bool] +} + +// DisabledDuringExecution returns the value of the disabledDuringExecution property. +func (o *SyncClientAction) DisabledDuringExecution() bool { + return o.disabledDuringExecution.Get() +} + +// SetDisabledDuringExecution sets the value of the disabledDuringExecution property. +func (o *SyncClientAction) SetDisabledDuringExecution(v bool) { + o.disabledDuringExecution.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SyncClientAction) InitFromRaw(raw bson.Raw) { + o.disabledDuringExecution.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TabContainer +// ──────────────────────────────────────────────────────── + +type TabContainer struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + tabPages *property.PartList[element.Element] + defaultPage *property.ByIdRef[element.Element] + activePageAttributeRef *property.Part[element.Element] + activePageSourceVariable *property.Part[element.Element] + activePageOnChangeAction *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *TabContainer) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TabContainer) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *TabContainer) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *TabContainer) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *TabContainer) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *TabContainer) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *TabContainer) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *TabContainer) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *TabContainer) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *TabContainer) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *TabContainer) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *TabContainer) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *TabContainer) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *TabContainer) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// TabPagesItems returns the value of the tabPages property. +func (o *TabContainer) TabPagesItems() []element.Element { + return o.tabPages.Items() +} + +// AddTabPages appends a child element to the tabPages list. +func (o *TabContainer) AddTabPages(v element.Element) { + o.tabPages.Append(v) +} + +// RemoveTabPages removes the element at the given index from the tabPages list. +func (o *TabContainer) RemoveTabPages(index int) { + o.tabPages.Remove(index) +} + +// DefaultPageRefID returns the value of the defaultPage property. +func (o *TabContainer) DefaultPageRefID() element.ID { + return o.defaultPage.RefID() +} + +// SetDefaultPageID sets the value of the defaultPage property. +func (o *TabContainer) SetDefaultPageID(v element.ID) { + o.defaultPage.SetID(v) +} + +// ActivePageAttributeRef returns the value of the activePageAttributeRef property. +func (o *TabContainer) ActivePageAttributeRef() element.Element { + return o.activePageAttributeRef.Get() +} + +// SetActivePageAttributeRef sets the value of the activePageAttributeRef property. +func (o *TabContainer) SetActivePageAttributeRef(v element.Element) { + o.activePageAttributeRef.Set(v) +} + +// ActivePageSourceVariable returns the value of the activePageSourceVariable property. +func (o *TabContainer) ActivePageSourceVariable() element.Element { + return o.activePageSourceVariable.Get() +} + +// SetActivePageSourceVariable sets the value of the activePageSourceVariable property. +func (o *TabContainer) SetActivePageSourceVariable(v element.Element) { + o.activePageSourceVariable.Set(v) +} + +// ActivePageOnChangeAction returns the value of the activePageOnChangeAction property. +func (o *TabContainer) ActivePageOnChangeAction() element.Element { + return o.activePageOnChangeAction.Get() +} + +// SetActivePageOnChangeAction sets the value of the activePageOnChangeAction property. +func (o *TabContainer) SetActivePageOnChangeAction(v element.Element) { + o.activePageOnChangeAction.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TabContainer) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "TabPages"); err == nil { + for _, child := range children { + o.tabPages.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("DefaultPage"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.defaultPage.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.defaultPage.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + if child, err := codec.DecodeChild(raw, "ActivePageAttributeRef"); err == nil { + o.activePageAttributeRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ActivePageSourceVariable"); err == nil { + o.activePageSourceVariable.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ActivePageOnChangeAction"); err == nil { + o.activePageOnChangeAction.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TabPage +// ──────────────────────────────────────────────────────── + +type TabPage struct { + element.Base + name *property.Primitive[string] + caption *property.Part[element.Element] + refreshOnShow *property.Primitive[bool] + conditionalVisibilitySettings *property.Part[element.Element] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + badge *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *TabPage) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TabPage) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *TabPage) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *TabPage) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// RefreshOnShow returns the value of the refreshOnShow property. +func (o *TabPage) RefreshOnShow() bool { + return o.refreshOnShow.Get() +} + +// SetRefreshOnShow sets the value of the refreshOnShow property. +func (o *TabPage) SetRefreshOnShow(v bool) { + o.refreshOnShow.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *TabPage) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *TabPage) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// Widget returns the value of the widget property. +func (o *TabPage) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *TabPage) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *TabPage) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *TabPage) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *TabPage) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// Badge returns the value of the badge property. +func (o *TabPage) Badge() element.Element { + return o.badge.Get() +} + +// SetBadge sets the value of the badge property. +func (o *TabPage) SetBadge(v element.Element) { + o.badge.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TabPage) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + o.refreshOnShow.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Badge"); err == nil { + o.badge.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Table +// ──────────────────────────────────────────────────────── + +type Table struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + cells *property.PartList[element.Element] + columns *property.PartList[element.Element] + widthUnit *property.Enum[string] + rows *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *Table) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Table) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *Table) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Table) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Table) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Table) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *Table) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *Table) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *Table) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *Table) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *Table) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *Table) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *Table) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *Table) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// CellsItems returns the value of the cells property. +func (o *Table) CellsItems() []element.Element { + return o.cells.Items() +} + +// AddCells appends a child element to the cells list. +func (o *Table) AddCells(v element.Element) { + o.cells.Append(v) +} + +// RemoveCells removes the element at the given index from the cells list. +func (o *Table) RemoveCells(index int) { + o.cells.Remove(index) +} + +// ColumnsItems returns the value of the columns property. +func (o *Table) ColumnsItems() []element.Element { + return o.columns.Items() +} + +// AddColumns appends a child element to the columns list. +func (o *Table) AddColumns(v element.Element) { + o.columns.Append(v) +} + +// RemoveColumns removes the element at the given index from the columns list. +func (o *Table) RemoveColumns(index int) { + o.columns.Remove(index) +} + +// WidthUnit returns the value of the widthUnit property. +func (o *Table) WidthUnit() string { + return o.widthUnit.Get() +} + +// SetWidthUnit sets the value of the widthUnit property. +func (o *Table) SetWidthUnit(v string) { + o.widthUnit.Set(v) +} + +// RowsItems returns the value of the rows property. +func (o *Table) RowsItems() []element.Element { + return o.rows.Items() +} + +// AddRows appends a child element to the rows list. +func (o *Table) AddRows(v element.Element) { + o.rows.Append(v) +} + +// RemoveRows removes the element at the given index from the rows list. +func (o *Table) RemoveRows(index int) { + o.rows.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Table) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Cells"); err == nil { + for _, child := range children { + o.cells.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Columns"); err == nil { + for _, child := range children { + o.columns.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("WidthUnit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.widthUnit.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Rows"); err == nil { + for _, child := range children { + o.rows.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// TableCell +// ──────────────────────────────────────────────────────── + +type TableCell struct { + element.Base + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + isHeader *property.Primitive[bool] + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] + leftColumnIndex *property.Primitive[int32] + topRowIndex *property.Primitive[int32] + width *property.Primitive[int32] + height *property.Primitive[int32] +} + +// Class returns the value of the class property. +func (o *TableCell) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *TableCell) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *TableCell) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *TableCell) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *TableCell) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *TableCell) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// IsHeader returns the value of the isHeader property. +func (o *TableCell) IsHeader() bool { + return o.isHeader.Get() +} + +// SetIsHeader sets the value of the isHeader property. +func (o *TableCell) SetIsHeader(v bool) { + o.isHeader.Set(v) +} + +// Widget returns the value of the widget property. +func (o *TableCell) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *TableCell) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *TableCell) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *TableCell) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *TableCell) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// LeftColumnIndex returns the value of the leftColumnIndex property. +func (o *TableCell) LeftColumnIndex() int32 { + return o.leftColumnIndex.Get() +} + +// SetLeftColumnIndex sets the value of the leftColumnIndex property. +func (o *TableCell) SetLeftColumnIndex(v int32) { + o.leftColumnIndex.Set(v) +} + +// TopRowIndex returns the value of the topRowIndex property. +func (o *TableCell) TopRowIndex() int32 { + return o.topRowIndex.Get() +} + +// SetTopRowIndex sets the value of the topRowIndex property. +func (o *TableCell) SetTopRowIndex(v int32) { + o.topRowIndex.Set(v) +} + +// Width returns the value of the width property. +func (o *TableCell) Width() int32 { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *TableCell) SetWidth(v int32) { + o.width.Set(v) +} + +// Height returns the value of the height property. +func (o *TableCell) Height() int32 { + return o.height.Get() +} + +// SetHeight sets the value of the height property. +func (o *TableCell) SetHeight(v int32) { + o.height.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TableCell) InitFromRaw(raw bson.Raw) { + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.isHeader.Init(raw) + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } + o.leftColumnIndex.Init(raw) + o.topRowIndex.Init(raw) + o.width.Init(raw) + o.height.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TableColumn +// ──────────────────────────────────────────────────────── + +type TableColumn struct { + element.Base + width *property.Primitive[int32] +} + +// Width returns the value of the width property. +func (o *TableColumn) Width() int32 { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *TableColumn) SetWidth(v int32) { + o.width.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TableColumn) InitFromRaw(raw bson.Raw) { + o.width.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TableRow +// ──────────────────────────────────────────────────────── + +type TableRow struct { + element.Base + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + conditionalVisibilitySettings *property.Part[element.Element] +} + +// Class returns the value of the class property. +func (o *TableRow) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *TableRow) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *TableRow) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *TableRow) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *TableRow) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *TableRow) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *TableRow) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *TableRow) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TableRow) InitFromRaw(raw bson.Raw) { + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TemplateGrid +// ──────────────────────────────────────────────────────── + +type TemplateGrid struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + dataSource *property.Part[element.Element] + isControlBarVisible *property.Primitive[bool] + isPagingEnabled *property.Primitive[bool] + showPagingBar *property.Enum[string] + selectionMode *property.Enum[string] + selectFirst *property.Primitive[bool] + defaultButtonTrigger *property.Enum[string] + refreshTime *property.Primitive[int32] + controlBar *property.Part[element.Element] + contents *property.Part[element.Element] + numberOfRows *property.Primitive[int32] + numberOfColumns *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *TemplateGrid) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TemplateGrid) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *TemplateGrid) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *TemplateGrid) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *TemplateGrid) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *TemplateGrid) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *TemplateGrid) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *TemplateGrid) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *TemplateGrid) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *TemplateGrid) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *TemplateGrid) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *TemplateGrid) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *TemplateGrid) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *TemplateGrid) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// DataSource returns the value of the dataSource property. +func (o *TemplateGrid) DataSource() element.Element { + return o.dataSource.Get() +} + +// SetDataSource sets the value of the dataSource property. +func (o *TemplateGrid) SetDataSource(v element.Element) { + o.dataSource.Set(v) +} + +// IsControlBarVisible returns the value of the isControlBarVisible property. +func (o *TemplateGrid) IsControlBarVisible() bool { + return o.isControlBarVisible.Get() +} + +// SetIsControlBarVisible sets the value of the isControlBarVisible property. +func (o *TemplateGrid) SetIsControlBarVisible(v bool) { + o.isControlBarVisible.Set(v) +} + +// IsPagingEnabled returns the value of the isPagingEnabled property. +func (o *TemplateGrid) IsPagingEnabled() bool { + return o.isPagingEnabled.Get() +} + +// SetIsPagingEnabled sets the value of the isPagingEnabled property. +func (o *TemplateGrid) SetIsPagingEnabled(v bool) { + o.isPagingEnabled.Set(v) +} + +// ShowPagingBar returns the value of the showPagingBar property. +func (o *TemplateGrid) ShowPagingBar() string { + return o.showPagingBar.Get() +} + +// SetShowPagingBar sets the value of the showPagingBar property. +func (o *TemplateGrid) SetShowPagingBar(v string) { + o.showPagingBar.Set(v) +} + +// SelectionMode returns the value of the selectionMode property. +func (o *TemplateGrid) SelectionMode() string { + return o.selectionMode.Get() +} + +// SetSelectionMode sets the value of the selectionMode property. +func (o *TemplateGrid) SetSelectionMode(v string) { + o.selectionMode.Set(v) +} + +// SelectFirst returns the value of the selectFirst property. +func (o *TemplateGrid) SelectFirst() bool { + return o.selectFirst.Get() +} + +// SetSelectFirst sets the value of the selectFirst property. +func (o *TemplateGrid) SetSelectFirst(v bool) { + o.selectFirst.Set(v) +} + +// DefaultButtonTrigger returns the value of the defaultButtonTrigger property. +func (o *TemplateGrid) DefaultButtonTrigger() string { + return o.defaultButtonTrigger.Get() +} + +// SetDefaultButtonTrigger sets the value of the defaultButtonTrigger property. +func (o *TemplateGrid) SetDefaultButtonTrigger(v string) { + o.defaultButtonTrigger.Set(v) +} + +// RefreshTime returns the value of the refreshTime property. +func (o *TemplateGrid) RefreshTime() int32 { + return o.refreshTime.Get() +} + +// SetRefreshTime sets the value of the refreshTime property. +func (o *TemplateGrid) SetRefreshTime(v int32) { + o.refreshTime.Set(v) +} + +// ControlBar returns the value of the controlBar property. +func (o *TemplateGrid) ControlBar() element.Element { + return o.controlBar.Get() +} + +// SetControlBar sets the value of the controlBar property. +func (o *TemplateGrid) SetControlBar(v element.Element) { + o.controlBar.Set(v) +} + +// Contents returns the value of the contents property. +func (o *TemplateGrid) Contents() element.Element { + return o.contents.Get() +} + +// SetContents sets the value of the contents property. +func (o *TemplateGrid) SetContents(v element.Element) { + o.contents.Set(v) +} + +// NumberOfRows returns the value of the numberOfRows property. +func (o *TemplateGrid) NumberOfRows() int32 { + return o.numberOfRows.Get() +} + +// SetNumberOfRows sets the value of the numberOfRows property. +func (o *TemplateGrid) SetNumberOfRows(v int32) { + o.numberOfRows.Set(v) +} + +// NumberOfColumns returns the value of the numberOfColumns property. +func (o *TemplateGrid) NumberOfColumns() int32 { + return o.numberOfColumns.Get() +} + +// SetNumberOfColumns sets the value of the numberOfColumns property. +func (o *TemplateGrid) SetNumberOfColumns(v int32) { + o.numberOfColumns.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TemplateGrid) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataSource"); err == nil { + o.dataSource.SetFromDecode(child) + } + o.isControlBarVisible.Init(raw) + o.isPagingEnabled.Init(raw) + if val, err := raw.LookupErr("ShowPagingBar"); err == nil { + if s, ok := val.StringValueOK(); ok { o.showPagingBar.SetFromDecode(s) } + } + if val, err := raw.LookupErr("SelectionMode"); err == nil { + if s, ok := val.StringValueOK(); ok { o.selectionMode.SetFromDecode(s) } + } + o.selectFirst.Init(raw) + if val, err := raw.LookupErr("DefaultButtonTrigger"); err == nil { + if s, ok := val.StringValueOK(); ok { o.defaultButtonTrigger.SetFromDecode(s) } + } + o.refreshTime.Init(raw) + if child, err := codec.DecodeChild(raw, "ControlBar"); err == nil { + o.controlBar.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Contents"); err == nil { + o.contents.SetFromDecode(child) + } + o.numberOfRows.Init(raw) + o.numberOfColumns.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TemplateGridContents +// ──────────────────────────────────────────────────────── + +type TemplateGridContents struct { + element.Base + widget *property.Part[element.Element] + widgets *property.PartList[element.Element] +} + +// Widget returns the value of the widget property. +func (o *TemplateGridContents) Widget() element.Element { + return o.widget.Get() +} + +// SetWidget sets the value of the widget property. +func (o *TemplateGridContents) SetWidget(v element.Element) { + o.widget.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *TemplateGridContents) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *TemplateGridContents) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *TemplateGridContents) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TemplateGridContents) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Widget"); err == nil { + o.widget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// TemplatePlaceholder +// ──────────────────────────────────────────────────────── + +type TemplatePlaceholder struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + propType *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *TemplatePlaceholder) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TemplatePlaceholder) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *TemplatePlaceholder) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *TemplatePlaceholder) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *TemplatePlaceholder) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *TemplatePlaceholder) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *TemplatePlaceholder) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *TemplatePlaceholder) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *TemplatePlaceholder) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *TemplatePlaceholder) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// Type returns the value of the type property. +func (o *TemplatePlaceholder) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *TemplatePlaceholder) SetType(v string) { + o.propType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TemplatePlaceholder) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + o.propType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TextWidget +// ──────────────────────────────────────────────────────── + +type TextWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + required *property.Primitive[bool] + requiredMessage *property.Part[element.Element] + validation *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onEnterMicroflowSettings *property.Part[element.Element] + onLeaveMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + onEnterAction *property.Part[element.Element] + onLeaveAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + ariaRequired *property.Primitive[bool] + placeholder *property.Part[element.Element] + placeholderTemplate *property.Part[element.Element] + maxLengthCode *property.Primitive[int32] + autoFocus *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *TextWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TextWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *TextWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *TextWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *TextWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *TextWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *TextWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *TextWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *TextWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *TextWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *TextWidget) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *TextWidget) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *TextWidget) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *TextWidget) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *TextWidget) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *TextWidget) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *TextWidget) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *TextWidget) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *TextWidget) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *TextWidget) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *TextWidget) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *TextWidget) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *TextWidget) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *TextWidget) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *TextWidget) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *TextWidget) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *TextWidget) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *TextWidget) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *TextWidget) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *TextWidget) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// Required returns the value of the required property. +func (o *TextWidget) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *TextWidget) SetRequired(v bool) { + o.required.Set(v) +} + +// RequiredMessage returns the value of the requiredMessage property. +func (o *TextWidget) RequiredMessage() element.Element { + return o.requiredMessage.Get() +} + +// SetRequiredMessage sets the value of the requiredMessage property. +func (o *TextWidget) SetRequiredMessage(v element.Element) { + o.requiredMessage.Set(v) +} + +// Validation returns the value of the validation property. +func (o *TextWidget) Validation() element.Element { + return o.validation.Get() +} + +// SetValidation sets the value of the validation property. +func (o *TextWidget) SetValidation(v element.Element) { + o.validation.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *TextWidget) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *TextWidget) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnEnterMicroflowSettings returns the value of the onEnterMicroflowSettings property. +func (o *TextWidget) OnEnterMicroflowSettings() element.Element { + return o.onEnterMicroflowSettings.Get() +} + +// SetOnEnterMicroflowSettings sets the value of the onEnterMicroflowSettings property. +func (o *TextWidget) SetOnEnterMicroflowSettings(v element.Element) { + o.onEnterMicroflowSettings.Set(v) +} + +// OnLeaveMicroflowSettings returns the value of the onLeaveMicroflowSettings property. +func (o *TextWidget) OnLeaveMicroflowSettings() element.Element { + return o.onLeaveMicroflowSettings.Get() +} + +// SetOnLeaveMicroflowSettings sets the value of the onLeaveMicroflowSettings property. +func (o *TextWidget) SetOnLeaveMicroflowSettings(v element.Element) { + o.onLeaveMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *TextWidget) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *TextWidget) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// OnEnterAction returns the value of the onEnterAction property. +func (o *TextWidget) OnEnterAction() element.Element { + return o.onEnterAction.Get() +} + +// SetOnEnterAction sets the value of the onEnterAction property. +func (o *TextWidget) SetOnEnterAction(v element.Element) { + o.onEnterAction.Set(v) +} + +// OnLeaveAction returns the value of the onLeaveAction property. +func (o *TextWidget) OnLeaveAction() element.Element { + return o.onLeaveAction.Get() +} + +// SetOnLeaveAction sets the value of the onLeaveAction property. +func (o *TextWidget) SetOnLeaveAction(v element.Element) { + o.onLeaveAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *TextWidget) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *TextWidget) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// AriaRequired returns the value of the ariaRequired property. +func (o *TextWidget) AriaRequired() bool { + return o.ariaRequired.Get() +} + +// SetAriaRequired sets the value of the ariaRequired property. +func (o *TextWidget) SetAriaRequired(v bool) { + o.ariaRequired.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *TextWidget) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *TextWidget) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// PlaceholderTemplate returns the value of the placeholderTemplate property. +func (o *TextWidget) PlaceholderTemplate() element.Element { + return o.placeholderTemplate.Get() +} + +// SetPlaceholderTemplate sets the value of the placeholderTemplate property. +func (o *TextWidget) SetPlaceholderTemplate(v element.Element) { + o.placeholderTemplate.Set(v) +} + +// MaxLengthCode returns the value of the maxLengthCode property. +func (o *TextWidget) MaxLengthCode() int32 { + return o.maxLengthCode.Get() +} + +// SetMaxLengthCode sets the value of the maxLengthCode property. +func (o *TextWidget) SetMaxLengthCode(v int32) { + o.maxLengthCode.Set(v) +} + +// AutoFocus returns the value of the autoFocus property. +func (o *TextWidget) AutoFocus() bool { + return o.autoFocus.Get() +} + +// SetAutoFocus sets the value of the autoFocus property. +func (o *TextWidget) SetAutoFocus(v bool) { + o.autoFocus.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TextWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + o.required.Init(raw) + if child, err := codec.DecodeChild(raw, "RequiredMessage"); err == nil { + o.requiredMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Validation"); err == nil { + o.validation.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterMicroflowSettings"); err == nil { + o.onEnterMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveMicroflowSettings"); err == nil { + o.onLeaveMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterAction"); err == nil { + o.onEnterAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveAction"); err == nil { + o.onLeaveAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.ariaRequired.Init(raw) + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "PlaceholderTemplate"); err == nil { + o.placeholderTemplate.SetFromDecode(child) + } + o.maxLengthCode.Init(raw) + o.autoFocus.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TextArea +// ──────────────────────────────────────────────────────── + +type TextArea struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + required *property.Primitive[bool] + requiredMessage *property.Part[element.Element] + validation *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onEnterMicroflowSettings *property.Part[element.Element] + onLeaveMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + onEnterAction *property.Part[element.Element] + onLeaveAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + ariaRequired *property.Primitive[bool] + placeholder *property.Part[element.Element] + placeholderTemplate *property.Part[element.Element] + maxLengthCode *property.Primitive[int32] + autoFocus *property.Primitive[bool] + numberOfLines *property.Primitive[int32] + counterMessage *property.Part[element.Element] + textTooLongMessage *property.Part[element.Element] + autocomplete *property.Primitive[bool] + submitBehaviour *property.Enum[string] + submitOnInputDelay *property.Primitive[int32] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *TextArea) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TextArea) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *TextArea) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *TextArea) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *TextArea) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *TextArea) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *TextArea) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *TextArea) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *TextArea) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *TextArea) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *TextArea) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *TextArea) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *TextArea) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *TextArea) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *TextArea) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *TextArea) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *TextArea) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *TextArea) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *TextArea) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *TextArea) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *TextArea) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *TextArea) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *TextArea) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *TextArea) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *TextArea) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *TextArea) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *TextArea) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *TextArea) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *TextArea) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *TextArea) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// Required returns the value of the required property. +func (o *TextArea) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *TextArea) SetRequired(v bool) { + o.required.Set(v) +} + +// RequiredMessage returns the value of the requiredMessage property. +func (o *TextArea) RequiredMessage() element.Element { + return o.requiredMessage.Get() +} + +// SetRequiredMessage sets the value of the requiredMessage property. +func (o *TextArea) SetRequiredMessage(v element.Element) { + o.requiredMessage.Set(v) +} + +// Validation returns the value of the validation property. +func (o *TextArea) Validation() element.Element { + return o.validation.Get() +} + +// SetValidation sets the value of the validation property. +func (o *TextArea) SetValidation(v element.Element) { + o.validation.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *TextArea) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *TextArea) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnEnterMicroflowSettings returns the value of the onEnterMicroflowSettings property. +func (o *TextArea) OnEnterMicroflowSettings() element.Element { + return o.onEnterMicroflowSettings.Get() +} + +// SetOnEnterMicroflowSettings sets the value of the onEnterMicroflowSettings property. +func (o *TextArea) SetOnEnterMicroflowSettings(v element.Element) { + o.onEnterMicroflowSettings.Set(v) +} + +// OnLeaveMicroflowSettings returns the value of the onLeaveMicroflowSettings property. +func (o *TextArea) OnLeaveMicroflowSettings() element.Element { + return o.onLeaveMicroflowSettings.Get() +} + +// SetOnLeaveMicroflowSettings sets the value of the onLeaveMicroflowSettings property. +func (o *TextArea) SetOnLeaveMicroflowSettings(v element.Element) { + o.onLeaveMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *TextArea) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *TextArea) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// OnEnterAction returns the value of the onEnterAction property. +func (o *TextArea) OnEnterAction() element.Element { + return o.onEnterAction.Get() +} + +// SetOnEnterAction sets the value of the onEnterAction property. +func (o *TextArea) SetOnEnterAction(v element.Element) { + o.onEnterAction.Set(v) +} + +// OnLeaveAction returns the value of the onLeaveAction property. +func (o *TextArea) OnLeaveAction() element.Element { + return o.onLeaveAction.Get() +} + +// SetOnLeaveAction sets the value of the onLeaveAction property. +func (o *TextArea) SetOnLeaveAction(v element.Element) { + o.onLeaveAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *TextArea) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *TextArea) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// AriaRequired returns the value of the ariaRequired property. +func (o *TextArea) AriaRequired() bool { + return o.ariaRequired.Get() +} + +// SetAriaRequired sets the value of the ariaRequired property. +func (o *TextArea) SetAriaRequired(v bool) { + o.ariaRequired.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *TextArea) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *TextArea) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// PlaceholderTemplate returns the value of the placeholderTemplate property. +func (o *TextArea) PlaceholderTemplate() element.Element { + return o.placeholderTemplate.Get() +} + +// SetPlaceholderTemplate sets the value of the placeholderTemplate property. +func (o *TextArea) SetPlaceholderTemplate(v element.Element) { + o.placeholderTemplate.Set(v) +} + +// MaxLengthCode returns the value of the maxLengthCode property. +func (o *TextArea) MaxLengthCode() int32 { + return o.maxLengthCode.Get() +} + +// SetMaxLengthCode sets the value of the maxLengthCode property. +func (o *TextArea) SetMaxLengthCode(v int32) { + o.maxLengthCode.Set(v) +} + +// AutoFocus returns the value of the autoFocus property. +func (o *TextArea) AutoFocus() bool { + return o.autoFocus.Get() +} + +// SetAutoFocus sets the value of the autoFocus property. +func (o *TextArea) SetAutoFocus(v bool) { + o.autoFocus.Set(v) +} + +// NumberOfLines returns the value of the numberOfLines property. +func (o *TextArea) NumberOfLines() int32 { + return o.numberOfLines.Get() +} + +// SetNumberOfLines sets the value of the numberOfLines property. +func (o *TextArea) SetNumberOfLines(v int32) { + o.numberOfLines.Set(v) +} + +// CounterMessage returns the value of the counterMessage property. +func (o *TextArea) CounterMessage() element.Element { + return o.counterMessage.Get() +} + +// SetCounterMessage sets the value of the counterMessage property. +func (o *TextArea) SetCounterMessage(v element.Element) { + o.counterMessage.Set(v) +} + +// TextTooLongMessage returns the value of the textTooLongMessage property. +func (o *TextArea) TextTooLongMessage() element.Element { + return o.textTooLongMessage.Get() +} + +// SetTextTooLongMessage sets the value of the textTooLongMessage property. +func (o *TextArea) SetTextTooLongMessage(v element.Element) { + o.textTooLongMessage.Set(v) +} + +// Autocomplete returns the value of the autocomplete property. +func (o *TextArea) Autocomplete() bool { + return o.autocomplete.Get() +} + +// SetAutocomplete sets the value of the autocomplete property. +func (o *TextArea) SetAutocomplete(v bool) { + o.autocomplete.Set(v) +} + +// SubmitBehaviour returns the value of the submitBehaviour property. +func (o *TextArea) SubmitBehaviour() string { + return o.submitBehaviour.Get() +} + +// SetSubmitBehaviour sets the value of the submitBehaviour property. +func (o *TextArea) SetSubmitBehaviour(v string) { + o.submitBehaviour.Set(v) +} + +// SubmitOnInputDelay returns the value of the submitOnInputDelay property. +func (o *TextArea) SubmitOnInputDelay() int32 { + return o.submitOnInputDelay.Get() +} + +// SetSubmitOnInputDelay sets the value of the submitOnInputDelay property. +func (o *TextArea) SetSubmitOnInputDelay(v int32) { + o.submitOnInputDelay.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *TextArea) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *TextArea) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TextArea) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + o.required.Init(raw) + if child, err := codec.DecodeChild(raw, "RequiredMessage"); err == nil { + o.requiredMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Validation"); err == nil { + o.validation.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterMicroflowSettings"); err == nil { + o.onEnterMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveMicroflowSettings"); err == nil { + o.onLeaveMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterAction"); err == nil { + o.onEnterAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveAction"); err == nil { + o.onLeaveAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.ariaRequired.Init(raw) + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "PlaceholderTemplate"); err == nil { + o.placeholderTemplate.SetFromDecode(child) + } + o.maxLengthCode.Init(raw) + o.autoFocus.Init(raw) + o.numberOfLines.Init(raw) + if child, err := codec.DecodeChild(raw, "CounterMessage"); err == nil { + o.counterMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TextTooLongMessage"); err == nil { + o.textTooLongMessage.SetFromDecode(child) + } + o.autocomplete.Init(raw) + if val, err := raw.LookupErr("SubmitBehaviour"); err == nil { + if s, ok := val.StringValueOK(); ok { o.submitBehaviour.SetFromDecode(s) } + } + o.submitOnInputDelay.Init(raw) + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// TextBox +// ──────────────────────────────────────────────────────── + +type TextBox struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + conditionalEditabilitySettings *property.Part[element.Element] + editable *property.Enum[string] + label *property.Part[element.Element] + labelTemplate *property.Part[element.Element] + screenReaderLabel *property.Part[element.Element] + attributePath *property.Primitive[string] + attributeRef *property.Part[element.Element] + readOnlyStyle *property.Enum[string] + required *property.Primitive[bool] + requiredMessage *property.Part[element.Element] + validation *property.Part[element.Element] + onChangeMicroflowSettings *property.Part[element.Element] + onEnterMicroflowSettings *property.Part[element.Element] + onLeaveMicroflowSettings *property.Part[element.Element] + onChangeAction *property.Part[element.Element] + onEnterAction *property.Part[element.Element] + onLeaveAction *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + ariaRequired *property.Primitive[bool] + placeholder *property.Part[element.Element] + placeholderTemplate *property.Part[element.Element] + maxLengthCode *property.Primitive[int32] + autoFocus *property.Primitive[bool] + inputMask *property.Primitive[string] + formattingInfo *property.Part[element.Element] + isPasswordBox *property.Primitive[bool] + keyboardType *property.Enum[string] + onEnterKeyPressAction *property.Part[element.Element] + autocomplete *property.Primitive[bool] + autocompletePurpose *property.Enum[string] + submitBehaviour *property.Enum[string] + submitOnInputDelay *property.Primitive[int32] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *TextBox) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *TextBox) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *TextBox) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *TextBox) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *TextBox) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *TextBox) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *TextBox) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *TextBox) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *TextBox) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *TextBox) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *TextBox) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *TextBox) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *TextBox) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *TextBox) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// ConditionalEditabilitySettings returns the value of the conditionalEditabilitySettings property. +func (o *TextBox) ConditionalEditabilitySettings() element.Element { + return o.conditionalEditabilitySettings.Get() +} + +// SetConditionalEditabilitySettings sets the value of the conditionalEditabilitySettings property. +func (o *TextBox) SetConditionalEditabilitySettings(v element.Element) { + o.conditionalEditabilitySettings.Set(v) +} + +// Editable returns the value of the editable property. +func (o *TextBox) Editable() string { + return o.editable.Get() +} + +// SetEditable sets the value of the editable property. +func (o *TextBox) SetEditable(v string) { + o.editable.Set(v) +} + +// Label returns the value of the label property. +func (o *TextBox) Label() element.Element { + return o.label.Get() +} + +// SetLabel sets the value of the label property. +func (o *TextBox) SetLabel(v element.Element) { + o.label.Set(v) +} + +// LabelTemplate returns the value of the labelTemplate property. +func (o *TextBox) LabelTemplate() element.Element { + return o.labelTemplate.Get() +} + +// SetLabelTemplate sets the value of the labelTemplate property. +func (o *TextBox) SetLabelTemplate(v element.Element) { + o.labelTemplate.Set(v) +} + +// ScreenReaderLabel returns the value of the screenReaderLabel property. +func (o *TextBox) ScreenReaderLabel() element.Element { + return o.screenReaderLabel.Get() +} + +// SetScreenReaderLabel sets the value of the screenReaderLabel property. +func (o *TextBox) SetScreenReaderLabel(v element.Element) { + o.screenReaderLabel.Set(v) +} + +// AttributePath returns the value of the attributePath property. +func (o *TextBox) AttributePath() string { + return o.attributePath.Get() +} + +// SetAttributePath sets the value of the attributePath property. +func (o *TextBox) SetAttributePath(v string) { + o.attributePath.Set(v) +} + +// AttributeRef returns the value of the attributeRef property. +func (o *TextBox) AttributeRef() element.Element { + return o.attributeRef.Get() +} + +// SetAttributeRef sets the value of the attributeRef property. +func (o *TextBox) SetAttributeRef(v element.Element) { + o.attributeRef.Set(v) +} + +// ReadOnlyStyle returns the value of the readOnlyStyle property. +func (o *TextBox) ReadOnlyStyle() string { + return o.readOnlyStyle.Get() +} + +// SetReadOnlyStyle sets the value of the readOnlyStyle property. +func (o *TextBox) SetReadOnlyStyle(v string) { + o.readOnlyStyle.Set(v) +} + +// Required returns the value of the required property. +func (o *TextBox) Required() bool { + return o.required.Get() +} + +// SetRequired sets the value of the required property. +func (o *TextBox) SetRequired(v bool) { + o.required.Set(v) +} + +// RequiredMessage returns the value of the requiredMessage property. +func (o *TextBox) RequiredMessage() element.Element { + return o.requiredMessage.Get() +} + +// SetRequiredMessage sets the value of the requiredMessage property. +func (o *TextBox) SetRequiredMessage(v element.Element) { + o.requiredMessage.Set(v) +} + +// Validation returns the value of the validation property. +func (o *TextBox) Validation() element.Element { + return o.validation.Get() +} + +// SetValidation sets the value of the validation property. +func (o *TextBox) SetValidation(v element.Element) { + o.validation.Set(v) +} + +// OnChangeMicroflowSettings returns the value of the onChangeMicroflowSettings property. +func (o *TextBox) OnChangeMicroflowSettings() element.Element { + return o.onChangeMicroflowSettings.Get() +} + +// SetOnChangeMicroflowSettings sets the value of the onChangeMicroflowSettings property. +func (o *TextBox) SetOnChangeMicroflowSettings(v element.Element) { + o.onChangeMicroflowSettings.Set(v) +} + +// OnEnterMicroflowSettings returns the value of the onEnterMicroflowSettings property. +func (o *TextBox) OnEnterMicroflowSettings() element.Element { + return o.onEnterMicroflowSettings.Get() +} + +// SetOnEnterMicroflowSettings sets the value of the onEnterMicroflowSettings property. +func (o *TextBox) SetOnEnterMicroflowSettings(v element.Element) { + o.onEnterMicroflowSettings.Set(v) +} + +// OnLeaveMicroflowSettings returns the value of the onLeaveMicroflowSettings property. +func (o *TextBox) OnLeaveMicroflowSettings() element.Element { + return o.onLeaveMicroflowSettings.Get() +} + +// SetOnLeaveMicroflowSettings sets the value of the onLeaveMicroflowSettings property. +func (o *TextBox) SetOnLeaveMicroflowSettings(v element.Element) { + o.onLeaveMicroflowSettings.Set(v) +} + +// OnChangeAction returns the value of the onChangeAction property. +func (o *TextBox) OnChangeAction() element.Element { + return o.onChangeAction.Get() +} + +// SetOnChangeAction sets the value of the onChangeAction property. +func (o *TextBox) SetOnChangeAction(v element.Element) { + o.onChangeAction.Set(v) +} + +// OnEnterAction returns the value of the onEnterAction property. +func (o *TextBox) OnEnterAction() element.Element { + return o.onEnterAction.Get() +} + +// SetOnEnterAction sets the value of the onEnterAction property. +func (o *TextBox) SetOnEnterAction(v element.Element) { + o.onEnterAction.Set(v) +} + +// OnLeaveAction returns the value of the onLeaveAction property. +func (o *TextBox) OnLeaveAction() element.Element { + return o.onLeaveAction.Get() +} + +// SetOnLeaveAction sets the value of the onLeaveAction property. +func (o *TextBox) SetOnLeaveAction(v element.Element) { + o.onLeaveAction.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *TextBox) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *TextBox) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// AriaRequired returns the value of the ariaRequired property. +func (o *TextBox) AriaRequired() bool { + return o.ariaRequired.Get() +} + +// SetAriaRequired sets the value of the ariaRequired property. +func (o *TextBox) SetAriaRequired(v bool) { + o.ariaRequired.Set(v) +} + +// Placeholder returns the value of the placeholder property. +func (o *TextBox) Placeholder() element.Element { + return o.placeholder.Get() +} + +// SetPlaceholder sets the value of the placeholder property. +func (o *TextBox) SetPlaceholder(v element.Element) { + o.placeholder.Set(v) +} + +// PlaceholderTemplate returns the value of the placeholderTemplate property. +func (o *TextBox) PlaceholderTemplate() element.Element { + return o.placeholderTemplate.Get() +} + +// SetPlaceholderTemplate sets the value of the placeholderTemplate property. +func (o *TextBox) SetPlaceholderTemplate(v element.Element) { + o.placeholderTemplate.Set(v) +} + +// MaxLengthCode returns the value of the maxLengthCode property. +func (o *TextBox) MaxLengthCode() int32 { + return o.maxLengthCode.Get() +} + +// SetMaxLengthCode sets the value of the maxLengthCode property. +func (o *TextBox) SetMaxLengthCode(v int32) { + o.maxLengthCode.Set(v) +} + +// AutoFocus returns the value of the autoFocus property. +func (o *TextBox) AutoFocus() bool { + return o.autoFocus.Get() +} + +// SetAutoFocus sets the value of the autoFocus property. +func (o *TextBox) SetAutoFocus(v bool) { + o.autoFocus.Set(v) +} + +// InputMask returns the value of the inputMask property. +func (o *TextBox) InputMask() string { + return o.inputMask.Get() +} + +// SetInputMask sets the value of the inputMask property. +func (o *TextBox) SetInputMask(v string) { + o.inputMask.Set(v) +} + +// FormattingInfo returns the value of the formattingInfo property. +func (o *TextBox) FormattingInfo() element.Element { + return o.formattingInfo.Get() +} + +// SetFormattingInfo sets the value of the formattingInfo property. +func (o *TextBox) SetFormattingInfo(v element.Element) { + o.formattingInfo.Set(v) +} + +// IsPasswordBox returns the value of the isPasswordBox property. +func (o *TextBox) IsPasswordBox() bool { + return o.isPasswordBox.Get() +} + +// SetIsPasswordBox sets the value of the isPasswordBox property. +func (o *TextBox) SetIsPasswordBox(v bool) { + o.isPasswordBox.Set(v) +} + +// KeyboardType returns the value of the keyboardType property. +func (o *TextBox) KeyboardType() string { + return o.keyboardType.Get() +} + +// SetKeyboardType sets the value of the keyboardType property. +func (o *TextBox) SetKeyboardType(v string) { + o.keyboardType.Set(v) +} + +// OnEnterKeyPressAction returns the value of the onEnterKeyPressAction property. +func (o *TextBox) OnEnterKeyPressAction() element.Element { + return o.onEnterKeyPressAction.Get() +} + +// SetOnEnterKeyPressAction sets the value of the onEnterKeyPressAction property. +func (o *TextBox) SetOnEnterKeyPressAction(v element.Element) { + o.onEnterKeyPressAction.Set(v) +} + +// Autocomplete returns the value of the autocomplete property. +func (o *TextBox) Autocomplete() bool { + return o.autocomplete.Get() +} + +// SetAutocomplete sets the value of the autocomplete property. +func (o *TextBox) SetAutocomplete(v bool) { + o.autocomplete.Set(v) +} + +// AutocompletePurpose returns the value of the autocompletePurpose property. +func (o *TextBox) AutocompletePurpose() string { + return o.autocompletePurpose.Get() +} + +// SetAutocompletePurpose sets the value of the autocompletePurpose property. +func (o *TextBox) SetAutocompletePurpose(v string) { + o.autocompletePurpose.Set(v) +} + +// SubmitBehaviour returns the value of the submitBehaviour property. +func (o *TextBox) SubmitBehaviour() string { + return o.submitBehaviour.Get() +} + +// SetSubmitBehaviour sets the value of the submitBehaviour property. +func (o *TextBox) SetSubmitBehaviour(v string) { + o.submitBehaviour.Set(v) +} + +// SubmitOnInputDelay returns the value of the submitOnInputDelay property. +func (o *TextBox) SubmitOnInputDelay() int32 { + return o.submitOnInputDelay.Get() +} + +// SetSubmitOnInputDelay sets the value of the submitOnInputDelay property. +func (o *TextBox) SetSubmitOnInputDelay(v int32) { + o.submitOnInputDelay.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *TextBox) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *TextBox) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TextBox) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ConditionalEditabilitySettings"); err == nil { + o.conditionalEditabilitySettings.SetFromDecode(child) + } + if val, err := raw.LookupErr("Editable"); err == nil { + if s, ok := val.StringValueOK(); ok { o.editable.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Label"); err == nil { + o.label.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "LabelTemplate"); err == nil { + o.labelTemplate.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ScreenReaderLabel"); err == nil { + o.screenReaderLabel.SetFromDecode(child) + } + o.attributePath.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeRef"); err == nil { + o.attributeRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("ReadOnlyStyle"); err == nil { + if s, ok := val.StringValueOK(); ok { o.readOnlyStyle.SetFromDecode(s) } + } + o.required.Init(raw) + if child, err := codec.DecodeChild(raw, "RequiredMessage"); err == nil { + o.requiredMessage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Validation"); err == nil { + o.validation.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeMicroflowSettings"); err == nil { + o.onChangeMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterMicroflowSettings"); err == nil { + o.onEnterMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveMicroflowSettings"); err == nil { + o.onLeaveMicroflowSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnChangeAction"); err == nil { + o.onChangeAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnEnterAction"); err == nil { + o.onEnterAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "OnLeaveAction"); err == nil { + o.onLeaveAction.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.ariaRequired.Init(raw) + if child, err := codec.DecodeChild(raw, "Placeholder"); err == nil { + o.placeholder.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "PlaceholderTemplate"); err == nil { + o.placeholderTemplate.SetFromDecode(child) + } + o.maxLengthCode.Init(raw) + o.autoFocus.Init(raw) + o.inputMask.Init(raw) + if child, err := codec.DecodeChild(raw, "FormattingInfo"); err == nil { + o.formattingInfo.SetFromDecode(child) + } + o.isPasswordBox.Init(raw) + if val, err := raw.LookupErr("KeyboardType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.keyboardType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "OnEnterKeyPressAction"); err == nil { + o.onEnterKeyPressAction.SetFromDecode(child) + } + o.autocomplete.Init(raw) + if val, err := raw.LookupErr("AutocompletePurpose"); err == nil { + if s, ok := val.StringValueOK(); ok { o.autocompletePurpose.SetFromDecode(s) } + } + if val, err := raw.LookupErr("SubmitBehaviour"); err == nil { + if s, ok := val.StringValueOK(); ok { o.submitBehaviour.SetFromDecode(s) } + } + o.submitOnInputDelay.Init(raw) + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Title +// ──────────────────────────────────────────────────────── + +type Title struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + conditionalVisibilitySettings *property.Part[element.Element] + accessibilitySettings *property.Part[element.Element] + nativeAccessibilitySettings *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *Title) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Title) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *Title) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *Title) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *Title) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *Title) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *Title) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *Title) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *Title) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *Title) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ConditionalVisibilitySettings returns the value of the conditionalVisibilitySettings property. +func (o *Title) ConditionalVisibilitySettings() element.Element { + return o.conditionalVisibilitySettings.Get() +} + +// SetConditionalVisibilitySettings sets the value of the conditionalVisibilitySettings property. +func (o *Title) SetConditionalVisibilitySettings(v element.Element) { + o.conditionalVisibilitySettings.Set(v) +} + +// AccessibilitySettings returns the value of the accessibilitySettings property. +func (o *Title) AccessibilitySettings() element.Element { + return o.accessibilitySettings.Get() +} + +// SetAccessibilitySettings sets the value of the accessibilitySettings property. +func (o *Title) SetAccessibilitySettings(v element.Element) { + o.accessibilitySettings.Set(v) +} + +// NativeAccessibilitySettings returns the value of the nativeAccessibilitySettings property. +func (o *Title) NativeAccessibilitySettings() element.Element { + return o.nativeAccessibilitySettings.Get() +} + +// SetNativeAccessibilitySettings sets the value of the nativeAccessibilitySettings property. +func (o *Title) SetNativeAccessibilitySettings(v element.Element) { + o.nativeAccessibilitySettings.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Title) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ConditionalVisibilitySettings"); err == nil { + o.conditionalVisibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AccessibilitySettings"); err == nil { + o.accessibilitySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "NativeAccessibilitySettings"); err == nil { + o.nativeAccessibilitySettings.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ToggleDesignPropertyValue +// ──────────────────────────────────────────────────────── + +type ToggleDesignPropertyValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ToggleDesignPropertyValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// UserRoleSet +// ──────────────────────────────────────────────────────── + +type UserRoleSet struct { + element.Base + userRoles *property.ByNameRefList[element.Element] +} + +// UserRolesQualifiedNames returns the value of the userRoles property. +func (o *UserRoleSet) UserRolesQualifiedNames() []string { + return o.userRoles.QualifiedNames() +} + +// SetUserRolesQualifiedNames sets the value of the userRoles property. +func (o *UserRoleSet) SetUserRolesQualifiedNames(v []string) { + o.userRoles.SetQualifiedNames(v) +} + +// AddUserRoles appends a child element to the userRoles list. +func (o *UserRoleSet) AddUserRoles(v string) { + o.userRoles.Append(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserRoleSet) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("UserRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.userRoles.SetFromDecode(qnames) + } + } +} + +// ──────────────────────────────────────────────────────── +// WorkflowTemplateType +// ──────────────────────────────────────────────────────── + +type WorkflowTemplateType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowTemplateType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// UserTaskTemplateType +// ──────────────────────────────────────────────────────── + +type UserTaskTemplateType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserTaskTemplateType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ValidationMessage +// ──────────────────────────────────────────────────────── + +type ValidationMessage struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *ValidationMessage) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ValidationMessage) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ValidationMessage) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ValidationMessage) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ValidationMessage) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ValidationMessage) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ValidationMessage) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ValidationMessage) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ValidationMessage) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ValidationMessage) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ValidationMessage) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// VerticalFlow +// ──────────────────────────────────────────────────────── + +type VerticalFlow struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + widgets *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *VerticalFlow) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *VerticalFlow) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *VerticalFlow) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *VerticalFlow) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *VerticalFlow) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *VerticalFlow) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *VerticalFlow) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *VerticalFlow) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *VerticalFlow) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *VerticalFlow) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *VerticalFlow) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *VerticalFlow) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *VerticalFlow) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VerticalFlow) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// VerticalSplitPane +// ──────────────────────────────────────────────────────── + +type VerticalSplitPane struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + firstWidget *property.Part[element.Element] + secondWidget *property.Part[element.Element] + firstWidgets *property.PartList[element.Element] + secondWidgets *property.PartList[element.Element] + animatedResize *property.Primitive[bool] + height *property.Primitive[int32] + position *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *VerticalSplitPane) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *VerticalSplitPane) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *VerticalSplitPane) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *VerticalSplitPane) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *VerticalSplitPane) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *VerticalSplitPane) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *VerticalSplitPane) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *VerticalSplitPane) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *VerticalSplitPane) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *VerticalSplitPane) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// FirstWidget returns the value of the firstWidget property. +func (o *VerticalSplitPane) FirstWidget() element.Element { + return o.firstWidget.Get() +} + +// SetFirstWidget sets the value of the firstWidget property. +func (o *VerticalSplitPane) SetFirstWidget(v element.Element) { + o.firstWidget.Set(v) +} + +// SecondWidget returns the value of the secondWidget property. +func (o *VerticalSplitPane) SecondWidget() element.Element { + return o.secondWidget.Get() +} + +// SetSecondWidget sets the value of the secondWidget property. +func (o *VerticalSplitPane) SetSecondWidget(v element.Element) { + o.secondWidget.Set(v) +} + +// FirstWidgetsItems returns the value of the firstWidgets property. +func (o *VerticalSplitPane) FirstWidgetsItems() []element.Element { + return o.firstWidgets.Items() +} + +// AddFirstWidgets appends a child element to the firstWidgets list. +func (o *VerticalSplitPane) AddFirstWidgets(v element.Element) { + o.firstWidgets.Append(v) +} + +// RemoveFirstWidgets removes the element at the given index from the firstWidgets list. +func (o *VerticalSplitPane) RemoveFirstWidgets(index int) { + o.firstWidgets.Remove(index) +} + +// SecondWidgetsItems returns the value of the secondWidgets property. +func (o *VerticalSplitPane) SecondWidgetsItems() []element.Element { + return o.secondWidgets.Items() +} + +// AddSecondWidgets appends a child element to the secondWidgets list. +func (o *VerticalSplitPane) AddSecondWidgets(v element.Element) { + o.secondWidgets.Append(v) +} + +// RemoveSecondWidgets removes the element at the given index from the secondWidgets list. +func (o *VerticalSplitPane) RemoveSecondWidgets(index int) { + o.secondWidgets.Remove(index) +} + +// AnimatedResize returns the value of the animatedResize property. +func (o *VerticalSplitPane) AnimatedResize() bool { + return o.animatedResize.Get() +} + +// SetAnimatedResize sets the value of the animatedResize property. +func (o *VerticalSplitPane) SetAnimatedResize(v bool) { + o.animatedResize.Set(v) +} + +// Height returns the value of the height property. +func (o *VerticalSplitPane) Height() int32 { + return o.height.Get() +} + +// SetHeight sets the value of the height property. +func (o *VerticalSplitPane) SetHeight(v int32) { + o.height.Set(v) +} + +// Position returns the value of the position property. +func (o *VerticalSplitPane) Position() int32 { + return o.position.Get() +} + +// SetPosition sets the value of the position property. +func (o *VerticalSplitPane) SetPosition(v int32) { + o.position.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VerticalSplitPane) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "FirstWidget"); err == nil { + o.firstWidget.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SecondWidget"); err == nil { + o.secondWidget.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "FirstWidgets"); err == nil { + for _, child := range children { + o.firstWidgets.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "SecondWidgets"); err == nil { + for _, child := range children { + o.secondWidgets.AppendFromDecode(child) + } + } + o.animatedResize.Init(raw) + o.height.Init(raw) + o.position.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WebLayoutContent +// ──────────────────────────────────────────────────────── + +type WebLayoutContent struct { + element.Base + layoutType *property.Enum[string] + layoutCall *property.Part[element.Element] + widgets *property.PartList[element.Element] +} + +// LayoutType returns the value of the layoutType property. +func (o *WebLayoutContent) LayoutType() string { + return o.layoutType.Get() +} + +// SetLayoutType sets the value of the layoutType property. +func (o *WebLayoutContent) SetLayoutType(v string) { + o.layoutType.Set(v) +} + +// LayoutCall returns the value of the layoutCall property. +func (o *WebLayoutContent) LayoutCall() element.Element { + return o.layoutCall.Get() +} + +// SetLayoutCall sets the value of the layoutCall property. +func (o *WebLayoutContent) SetLayoutCall(v element.Element) { + o.layoutCall.Set(v) +} + +// WidgetsItems returns the value of the widgets property. +func (o *WebLayoutContent) WidgetsItems() []element.Element { + return o.widgets.Items() +} + +// AddWidgets appends a child element to the widgets list. +func (o *WebLayoutContent) AddWidgets(v element.Element) { + o.widgets.Append(v) +} + +// RemoveWidgets removes the element at the given index from the widgets list. +func (o *WebLayoutContent) RemoveWidgets(index int) { + o.widgets.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WebLayoutContent) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("LayoutType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.layoutType.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "LayoutCall"); err == nil { + o.layoutCall.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Widgets"); err == nil { + for _, child := range children { + o.widgets.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// WidgetValidation +// ──────────────────────────────────────────────────────── + +type WidgetValidation struct { + element.Base + expression *property.Primitive[string] + expressionModel *property.Part[element.Element] + message *property.Part[element.Element] +} + +// Expression returns the value of the expression property. +func (o *WidgetValidation) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *WidgetValidation) SetExpression(v string) { + o.expression.Set(v) +} + +// ExpressionModel returns the value of the expressionModel property. +func (o *WidgetValidation) ExpressionModel() element.Element { + return o.expressionModel.Get() +} + +// SetExpressionModel sets the value of the expressionModel property. +func (o *WidgetValidation) SetExpressionModel(v element.Element) { + o.expressionModel.Set(v) +} + +// Message returns the value of the message property. +func (o *WidgetValidation) Message() element.Element { + return o.message.Get() +} + +// SetMessage sets the value of the message property. +func (o *WidgetValidation) SetMessage(v element.Element) { + o.message.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WidgetValidation) InitFromRaw(raw bson.Raw) { + o.expression.Init(raw) + if child, err := codec.DecodeChild(raw, "ExpressionModel"); err == nil { + o.expressionModel.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Message"); err == nil { + o.message.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// WorkflowOverviewTemplateType +// ──────────────────────────────────────────────────────── + +type WorkflowOverviewTemplateType struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowOverviewTemplateType) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initAccessibilitySettings creates a AccessibilitySettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAccessibilitySettings() *AccessibilitySettings { + o := &AccessibilitySettings{} + o.SetTypeName("Forms$AccessibilitySettings") + o.screenReaderDescription = property.NewPart[element.Element]("ScreenReaderDescription") + o.screenReaderDescription.Bind(&o.Base, 0) + o.screenReaderTitle = property.NewPart[element.Element]("ScreenReaderTitle") + o.screenReaderTitle.Bind(&o.Base, 1) + o.accessible = property.NewPrimitive[bool]("Accessible", property.DecodeBool) + o.accessible.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.screenReaderDescription, o.screenReaderTitle, o.accessible, }) + return o +} + +// NewAccessibilitySettings creates a new AccessibilitySettings for user code. Marked dirty (bit 63 = new element). +func NewAccessibilitySettings() *AccessibilitySettings { + o := initAccessibilitySettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initActionButton creates a ActionButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initActionButton() *ActionButton { + o := &ActionButton{} + o.SetTypeName("Forms$ActionButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.action = property.NewPart[element.Element]("Action") + o.action.Bind(&o.Base, 12) + o.ariaRole = property.NewEnum[string]("AriaRole") + o.ariaRole.Bind(&o.Base, 13) + o.disabledDuringAction = property.NewPrimitive[bool]("DisabledDuringAction", property.DecodeBool) + o.disabledDuringAction.Bind(&o.Base, 14) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, o.action, o.ariaRole, o.disabledDuringAction, o.nativeAccessibilitySettings, }) + return o +} + +// NewActionButton creates a new ActionButton for user code. Marked dirty (bit 63 = new element). +func NewActionButton() *ActionButton { + o := initActionButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAppearance creates a Appearance with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAppearance() *Appearance { + o := &Appearance{} + o.SetTypeName("Forms$Appearance") + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 0) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 1) + o.designProperties = property.NewPartList[element.Element]("DesignProperties") + o.designProperties.Bind(&o.Base, 2) + o.dynamicClasses = property.NewPrimitive[string]("DynamicClasses", property.DecodeString) + o.dynamicClasses.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.class, o.style, o.designProperties, o.dynamicClasses, }) + return o +} + +// NewAppearance creates a new Appearance for user code. Marked dirty (bit 63 = new element). +func NewAppearance() *Appearance { + o := initAppearance() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAssociationSource creates a AssociationSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAssociationSource() *AssociationSource { + o := &AssociationSource{} + o.SetTypeName("Forms$AssociationSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, }) + return o +} + +// NewAssociationSource creates a new AssociationSource for user code. Marked dirty (bit 63 = new element). +func NewAssociationSource() *AssociationSource { + o := initAssociationSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBackButton creates a BackButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBackButton() *BackButton { + o := &BackButton{} + o.SetTypeName("Forms$BackButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, }) + return o +} + +// NewBackButton creates a new BackButton for user code. Marked dirty (bit 63 = new element). +func NewBackButton() *BackButton { + o := initBackButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBuildingBlock creates a BuildingBlock with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBuildingBlock() *BuildingBlock { + o := &BuildingBlock{} + o.SetTypeName("Forms$BuildingBlock") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.canvasWidth = property.NewPrimitive[int32]("CanvasWidth", property.DecodeInt32) + o.canvasWidth.Bind(&o.Base, 4) + o.canvasHeight = property.NewPrimitive[int32]("CanvasHeight", property.DecodeInt32) + o.canvasHeight.Bind(&o.Base, 5) + o.displayName = property.NewPrimitive[string]("DisplayName", property.DecodeString) + o.displayName.Bind(&o.Base, 6) + o.documentationUrl = property.NewPrimitive[string]("DocumentationUrl", property.DecodeString) + o.documentationUrl.Bind(&o.Base, 7) + o.templateCategory = property.NewPrimitive[string]("TemplateCategory", property.DecodeString) + o.templateCategory.Bind(&o.Base, 8) + o.templateCategoryWeight = property.NewPrimitive[int32]("TemplateCategoryWeight", property.DecodeInt32) + o.templateCategoryWeight.Bind(&o.Base, 9) + o.imageData = property.NewPrimitive[string]("ImageData", property.DecodeString) + o.imageData.Bind(&o.Base, 10) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 11) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 12) + o.platform = property.NewEnum[string]("Platform") + o.platform.Bind(&o.Base, 13) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.canvasWidth, o.canvasHeight, o.displayName, o.documentationUrl, o.templateCategory, o.templateCategoryWeight, o.imageData, o.widget, o.widgets, o.platform, }) + return o +} + +// NewBuildingBlock creates a new BuildingBlock for user code. Marked dirty (bit 63 = new element). +func NewBuildingBlock() *BuildingBlock { + o := initBuildingBlock() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCallNanoflowClientAction creates a CallNanoflowClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCallNanoflowClientAction() *CallNanoflowClientAction { + o := &CallNanoflowClientAction{} + o.SetTypeName("Forms$CallNanoflowClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.nanoflow = property.NewByNameRef[element.Element]("Nanoflow", "Microflows$Nanoflow") + o.nanoflow.Bind(&o.Base, 1) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 2) + o.progressBar = property.NewEnum[string]("ProgressBar") + o.progressBar.Bind(&o.Base, 3) + o.progressMessage = property.NewPart[element.Element]("ProgressMessage") + o.progressMessage.Bind(&o.Base, 4) + o.confirmationInfo = property.NewPart[element.Element]("ConfirmationInfo") + o.confirmationInfo.Bind(&o.Base, 5) + o.outputMappings = property.NewPartList[element.Element]("OutputMappings") + o.outputMappings.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.nanoflow, o.parameterMappings, o.progressBar, o.progressMessage, o.confirmationInfo, o.outputMappings, }) + return o +} + +// NewCallNanoflowClientAction creates a new CallNanoflowClientAction for user code. Marked dirty (bit 63 = new element). +func NewCallNanoflowClientAction() *CallNanoflowClientAction { + o := initCallNanoflowClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCallWorkflowClientAction creates a CallWorkflowClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCallWorkflowClientAction() *CallWorkflowClientAction { + o := &CallWorkflowClientAction{} + o.SetTypeName("Forms$CallWorkflowClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.workflow = property.NewByNameRef[element.Element]("Workflow", "Workflows$Workflow") + o.workflow.Bind(&o.Base, 1) + o.closePage = property.NewPrimitive[bool]("ClosePage", property.DecodeBool) + o.closePage.Bind(&o.Base, 2) + o.commit = property.NewPrimitive[bool]("Commit", property.DecodeBool) + o.commit.Bind(&o.Base, 3) + o.confirmationInfo = property.NewPart[element.Element]("ConfirmationInfo") + o.confirmationInfo.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.workflow, o.closePage, o.commit, o.confirmationInfo, }) + return o +} + +// NewCallWorkflowClientAction creates a new CallWorkflowClientAction for user code. Marked dirty (bit 63 = new element). +func NewCallWorkflowClientAction() *CallWorkflowClientAction { + o := initCallWorkflowClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCancelButton creates a CancelButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCancelButton() *CancelButton { + o := &CancelButton{} + o.SetTypeName("Forms$CancelButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.closePage = property.NewPrimitive[bool]("ClosePage", property.DecodeBool) + o.closePage.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, o.closePage, }) + return o +} + +// NewCancelButton creates a new CancelButton for user code. Marked dirty (bit 63 = new element). +func NewCancelButton() *CancelButton { + o := initCancelButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCancelChangesClientAction creates a CancelChangesClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCancelChangesClientAction() *CancelChangesClientAction { + o := &CancelChangesClientAction{} + o.SetTypeName("Forms$CancelChangesClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.closePage = property.NewPrimitive[bool]("ClosePage", property.DecodeBool) + o.closePage.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.closePage, }) + return o +} + +// NewCancelChangesClientAction creates a new CancelChangesClientAction for user code. Marked dirty (bit 63 = new element). +func NewCancelChangesClientAction() *CancelChangesClientAction { + o := initCancelChangesClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCancelSynchronizationClientAction creates a CancelSynchronizationClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCancelSynchronizationClientAction() *CancelSynchronizationClientAction { + o := &CancelSynchronizationClientAction{} + o.SetTypeName("Forms$CancelSynchronizationClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.disabledDuringExecution, }) + return o +} + +// NewCancelSynchronizationClientAction creates a new CancelSynchronizationClientAction for user code. Marked dirty (bit 63 = new element). +func NewCancelSynchronizationClientAction() *CancelSynchronizationClientAction { + o := initCancelSynchronizationClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCheckBox creates a CheckBox with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCheckBox() *CheckBox { + o := &CheckBox{} + o.SetTypeName("Forms$CheckBox") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 7) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 8) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 9) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 10) + o.screenReaderLabel = property.NewPart[element.Element]("ScreenReaderLabel") + o.screenReaderLabel.Bind(&o.Base, 11) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 12) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 13) + o.readOnlyStyle = property.NewEnum[string]("ReadOnlyStyle") + o.readOnlyStyle.Bind(&o.Base, 14) + o.required = property.NewPrimitive[bool]("Required", property.DecodeBool) + o.required.Bind(&o.Base, 15) + o.requiredMessage = property.NewPart[element.Element]("RequiredMessage") + o.requiredMessage.Bind(&o.Base, 16) + o.validation = property.NewPart[element.Element]("Validation") + o.validation.Bind(&o.Base, 17) + o.onChangeMicroflowSettings = property.NewPart[element.Element]("OnChangeMicroflowSettings") + o.onChangeMicroflowSettings.Bind(&o.Base, 18) + o.onEnterMicroflowSettings = property.NewPart[element.Element]("OnEnterMicroflowSettings") + o.onEnterMicroflowSettings.Bind(&o.Base, 19) + o.onLeaveMicroflowSettings = property.NewPart[element.Element]("OnLeaveMicroflowSettings") + o.onLeaveMicroflowSettings.Bind(&o.Base, 20) + o.onChangeAction = property.NewPart[element.Element]("OnChangeAction") + o.onChangeAction.Bind(&o.Base, 21) + o.onEnterAction = property.NewPart[element.Element]("OnEnterAction") + o.onEnterAction.Bind(&o.Base, 22) + o.onLeaveAction = property.NewPart[element.Element]("OnLeaveAction") + o.onLeaveAction.Bind(&o.Base, 23) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 24) + o.ariaRequired = property.NewPrimitive[bool]("AriaRequired", property.DecodeBool) + o.ariaRequired.Bind(&o.Base, 25) + o.labelPosition = property.NewEnum[string]("LabelPosition") + o.labelPosition.Bind(&o.Base, 26) + o.nativeRenderMode = property.NewEnum[string]("NativeRenderMode") + o.nativeRenderMode.Bind(&o.Base, 27) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 28) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.conditionalEditabilitySettings, o.editable, o.label, o.labelTemplate, o.screenReaderLabel, o.attributePath, o.attributeRef, o.readOnlyStyle, o.required, o.requiredMessage, o.validation, o.onChangeMicroflowSettings, o.onEnterMicroflowSettings, o.onLeaveMicroflowSettings, o.onChangeAction, o.onEnterAction, o.onLeaveAction, o.sourceVariable, o.ariaRequired, o.labelPosition, o.nativeRenderMode, o.nativeAccessibilitySettings, }) + return o +} + +// NewCheckBox creates a new CheckBox for user code. Marked dirty (bit 63 = new element). +func NewCheckBox() *CheckBox { + o := initCheckBox() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initClientTemplate creates a ClientTemplate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initClientTemplate() *ClientTemplate { + o := &ClientTemplate{} + o.SetTypeName("Forms$ClientTemplate") + o.template = property.NewPart[element.Element]("Template") + o.template.Bind(&o.Base, 0) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 1) + o.fallback = property.NewPart[element.Element]("Fallback") + o.fallback.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.template, o.parameters, o.fallback, }) + return o +} + +// NewClientTemplate creates a new ClientTemplate for user code. Marked dirty (bit 63 = new element). +func NewClientTemplate() *ClientTemplate { + o := initClientTemplate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initClientTemplateParameter creates a ClientTemplateParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initClientTemplateParameter() *ClientTemplateParameter { + o := &ClientTemplateParameter{} + o.SetTypeName("Forms$ClientTemplateParameter") + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 0) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 1) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 2) + o.formattingInfo = property.NewPart[element.Element]("FormattingInfo") + o.formattingInfo.Bind(&o.Base, 3) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.attributePath, o.attributeRef, o.expression, o.formattingInfo, o.sourceVariable, }) + return o +} + +// NewClientTemplateParameter creates a new ClientTemplateParameter for user code. Marked dirty (bit 63 = new element). +func NewClientTemplateParameter() *ClientTemplateParameter { + o := initClientTemplateParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initClosePageClientAction creates a ClosePageClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initClosePageClientAction() *ClosePageClientAction { + o := &ClosePageClientAction{} + o.SetTypeName("Forms$ClosePageClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.numberOfPages = property.NewPrimitive[int32]("NumberOfPages", property.DecodeInt32) + o.numberOfPages.Bind(&o.Base, 1) + o.numberOfPagesToClose = property.NewPrimitive[string]("NumberOfPagesToClose", property.DecodeString) + o.numberOfPagesToClose.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.numberOfPages, o.numberOfPagesToClose, }) + return o +} + +// NewClosePageClientAction creates a new ClosePageClientAction for user code. Marked dirty (bit 63 = new element). +func NewClosePageClientAction() *ClosePageClientAction { + o := initClosePageClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initComparisonSearchField creates a ComparisonSearchField with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initComparisonSearchField() *ComparisonSearchField { + o := &ComparisonSearchField{} + o.SetTypeName("Forms$ComparisonSearchField") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.placeholder = property.NewPart[element.Element]("Placeholder") + o.placeholder.Bind(&o.Base, 2) + o.customDateFormat = property.NewPrimitive[string]("CustomDateFormat", property.DecodeString) + o.customDateFormat.Bind(&o.Base, 3) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 4) + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 5) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 6) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 7) + o.operator = property.NewEnum[string]("Operator") + o.operator.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.caption, o.placeholder, o.customDateFormat, o.propType, o.defaultValue, o.attributePath, o.attributeRef, o.operator, }) + return o +} + +// NewComparisonSearchField creates a new ComparisonSearchField for user code. Marked dirty (bit 63 = new element). +func NewComparisonSearchField() *ComparisonSearchField { + o := initComparisonSearchField() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCompoundDesignPropertyValue creates a CompoundDesignPropertyValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCompoundDesignPropertyValue() *CompoundDesignPropertyValue { + o := &CompoundDesignPropertyValue{} + o.SetTypeName("Forms$CompoundDesignPropertyValue") + o.properties = property.NewPartList[element.Element]("Properties") + o.properties.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.properties, }) + return o +} + +// NewCompoundDesignPropertyValue creates a new CompoundDesignPropertyValue for user code. Marked dirty (bit 63 = new element). +func NewCompoundDesignPropertyValue() *CompoundDesignPropertyValue { + o := initCompoundDesignPropertyValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConditionalEditabilitySettings creates a ConditionalEditabilitySettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConditionalEditabilitySettings() *ConditionalEditabilitySettings { + o := &ConditionalEditabilitySettings{} + o.SetTypeName("Forms$ConditionalEditabilitySettings") + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 0) + o.conditions = property.NewPartList[element.Element]("Conditions") + o.conditions.Bind(&o.Base, 1) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.expressionModel = property.NewPart[element.Element]("ExpressionModel") + o.expressionModel.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.attribute, o.conditions, o.expression, o.sourceVariable, o.expressionModel, }) + return o +} + +// NewConditionalEditabilitySettings creates a new ConditionalEditabilitySettings for user code. Marked dirty (bit 63 = new element). +func NewConditionalEditabilitySettings() *ConditionalEditabilitySettings { + o := initConditionalEditabilitySettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConditionalVisibilitySettings creates a ConditionalVisibilitySettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConditionalVisibilitySettings() *ConditionalVisibilitySettings { + o := &ConditionalVisibilitySettings{} + o.SetTypeName("Forms$ConditionalVisibilitySettings") + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 0) + o.conditions = property.NewPartList[element.Element]("Conditions") + o.conditions.Bind(&o.Base, 1) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.expressionModel = property.NewPart[element.Element]("ExpressionModel") + o.expressionModel.Bind(&o.Base, 4) + o.moduleRoles = property.NewByNameRefList[element.Element]("ModuleRoles", "Security$ModuleRole") + o.moduleRoles.Bind(&o.Base, 5) + o.ignoreSecurity = property.NewPrimitive[bool]("IgnoreSecurity", property.DecodeBool) + o.ignoreSecurity.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.attribute, o.conditions, o.expression, o.sourceVariable, o.expressionModel, o.moduleRoles, o.ignoreSecurity, }) + return o +} + +// NewConditionalVisibilitySettings creates a new ConditionalVisibilitySettings for user code. Marked dirty (bit 63 = new element). +func NewConditionalVisibilitySettings() *ConditionalVisibilitySettings { + o := initConditionalVisibilitySettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConfirmationInfo creates a ConfirmationInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConfirmationInfo() *ConfirmationInfo { + o := &ConfirmationInfo{} + o.SetTypeName("Forms$ConfirmationInfo") + o.question = property.NewPart[element.Element]("Question") + o.question.Bind(&o.Base, 0) + o.proceedButtonCaption = property.NewPart[element.Element]("ProceedButtonCaption") + o.proceedButtonCaption.Bind(&o.Base, 1) + o.cancelButtonCaption = property.NewPart[element.Element]("CancelButtonCaption") + o.cancelButtonCaption.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.question, o.proceedButtonCaption, o.cancelButtonCaption, }) + return o +} + +// NewConfirmationInfo creates a new ConfirmationInfo for user code. Marked dirty (bit 63 = new element). +func NewConfirmationInfo() *ConfirmationInfo { + o := initConfirmationInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCreateObjectClientAction creates a CreateObjectClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCreateObjectClientAction() *CreateObjectClientAction { + o := &CreateObjectClientAction{} + o.SetTypeName("Forms$CreateObjectClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 1) + o.pageSettings = property.NewPart[element.Element]("PageSettings") + o.pageSettings.Bind(&o.Base, 2) + o.numberOfPagesToClose = property.NewPrimitive[int32]("NumberOfPagesToClose", property.DecodeInt32) + o.numberOfPagesToClose.Bind(&o.Base, 3) + o.numberOfPagesToClose2 = property.NewPrimitive[string]("NumberOfPagesToClose2", property.DecodeString) + o.numberOfPagesToClose2.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.entityRef, o.pageSettings, o.numberOfPagesToClose, o.numberOfPagesToClose2, }) + return o +} + +// NewCreateObjectClientAction creates a new CreateObjectClientAction for user code. Marked dirty (bit 63 = new element). +func NewCreateObjectClientAction() *CreateObjectClientAction { + o := initCreateObjectClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomDesignPropertyValue creates a CustomDesignPropertyValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomDesignPropertyValue() *CustomDesignPropertyValue { + o := &CustomDesignPropertyValue{} + o.SetTypeName("Forms$CustomDesignPropertyValue") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value, }) + return o +} + +// NewCustomDesignPropertyValue creates a new CustomDesignPropertyValue for user code. Marked dirty (bit 63 = new element). +func NewCustomDesignPropertyValue() *CustomDesignPropertyValue { + o := initCustomDesignPropertyValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataGrid creates a DataGrid with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataGrid() *DataGrid { + o := &DataGrid{} + o.SetTypeName("Forms$DataGrid") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.dataSource = property.NewPart[element.Element]("DataSource") + o.dataSource.Bind(&o.Base, 7) + o.isControlBarVisible = property.NewPrimitive[bool]("IsControlBarVisible", property.DecodeBool) + o.isControlBarVisible.Bind(&o.Base, 8) + o.isPagingEnabled = property.NewPrimitive[bool]("IsPagingEnabled", property.DecodeBool) + o.isPagingEnabled.Bind(&o.Base, 9) + o.showPagingBar = property.NewEnum[string]("ShowPagingBar") + o.showPagingBar.Bind(&o.Base, 10) + o.selectionMode = property.NewEnum[string]("SelectionMode") + o.selectionMode.Bind(&o.Base, 11) + o.selectFirst = property.NewPrimitive[bool]("SelectFirst", property.DecodeBool) + o.selectFirst.Bind(&o.Base, 12) + o.defaultButtonTrigger = property.NewEnum[string]("DefaultButtonTrigger") + o.defaultButtonTrigger.Bind(&o.Base, 13) + o.refreshTime = property.NewPrimitive[int32]("RefreshTime", property.DecodeInt32) + o.refreshTime.Bind(&o.Base, 14) + o.controlBar = property.NewPart[element.Element]("ControlBar") + o.controlBar.Bind(&o.Base, 15) + o.columns = property.NewPartList[element.Element]("Columns") + o.columns.Bind(&o.Base, 16) + o.numberOfRows = property.NewPrimitive[int32]("NumberOfRows", property.DecodeInt32) + o.numberOfRows.Bind(&o.Base, 17) + o.showEmptyRows = property.NewPrimitive[bool]("ShowEmptyRows", property.DecodeBool) + o.showEmptyRows.Bind(&o.Base, 18) + o.widthUnit = property.NewEnum[string]("WidthUnit") + o.widthUnit.Bind(&o.Base, 19) + o.tooltipPage = property.NewByNameRef[element.Element]("TooltipPage", "Forms$Page") + o.tooltipPage.Bind(&o.Base, 20) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 21) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.dataSource, o.isControlBarVisible, o.isPagingEnabled, o.showPagingBar, o.selectionMode, o.selectFirst, o.defaultButtonTrigger, o.refreshTime, o.controlBar, o.columns, o.numberOfRows, o.showEmptyRows, o.widthUnit, o.tooltipPage, o.caption, }) + return o +} + +// NewDataGrid creates a new DataGrid for user code. Marked dirty (bit 63 = new element). +func NewDataGrid() *DataGrid { + o := initDataGrid() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataGridAddButton creates a DataGridAddButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataGridAddButton() *DataGridAddButton { + o := &DataGridAddButton{} + o.SetTypeName("Forms$DataGridAddButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.pageSettings = property.NewPart[element.Element]("PageSettings") + o.pageSettings.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.pageSettings, }) + return o +} + +// NewDataGridAddButton creates a new DataGridAddButton for user code. Marked dirty (bit 63 = new element). +func NewDataGridAddButton() *DataGridAddButton { + o := initDataGridAddButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataGridExportToCSVButton creates a DataGridExportToCSVButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataGridExportToCSVButton() *DataGridExportToCSVButton { + o := &DataGridExportToCSVButton{} + o.SetTypeName("Forms$DataGridExportToCSVButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.maxNumberOfRows = property.NewPrimitive[int32]("MaxNumberOfRows", property.DecodeInt32) + o.maxNumberOfRows.Bind(&o.Base, 9) + o.decimalSeparator = property.NewPrimitive[string]("DecimalSeparator", property.DecodeString) + o.decimalSeparator.Bind(&o.Base, 10) + o.groupSeparator = property.NewPrimitive[string]("GroupSeparator", property.DecodeString) + o.groupSeparator.Bind(&o.Base, 11) + o.delimiter = property.NewPrimitive[string]("Delimiter", property.DecodeString) + o.delimiter.Bind(&o.Base, 12) + o.generateExcelHint = property.NewPrimitive[bool]("GenerateExcelHint", property.DecodeBool) + o.generateExcelHint.Bind(&o.Base, 13) + o.useGridDateFormat = property.NewPrimitive[bool]("UseGridDateFormat", property.DecodeBool) + o.useGridDateFormat.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.maxNumberOfRows, o.decimalSeparator, o.groupSeparator, o.delimiter, o.generateExcelHint, o.useGridDateFormat, }) + return o +} + +// NewDataGridExportToCSVButton creates a new DataGridExportToCSVButton for user code. Marked dirty (bit 63 = new element). +func NewDataGridExportToCSVButton() *DataGridExportToCSVButton { + o := initDataGridExportToCSVButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataGridExportToExcelButton creates a DataGridExportToExcelButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataGridExportToExcelButton() *DataGridExportToExcelButton { + o := &DataGridExportToExcelButton{} + o.SetTypeName("Forms$DataGridExportToExcelButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.maxNumberOfRows = property.NewPrimitive[int32]("MaxNumberOfRows", property.DecodeInt32) + o.maxNumberOfRows.Bind(&o.Base, 9) + o.useExcelDateType = property.NewPrimitive[bool]("UseExcelDateType", property.DecodeBool) + o.useExcelDateType.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.maxNumberOfRows, o.useExcelDateType, }) + return o +} + +// NewDataGridExportToExcelButton creates a new DataGridExportToExcelButton for user code. Marked dirty (bit 63 = new element). +func NewDataGridExportToExcelButton() *DataGridExportToExcelButton { + o := initDataGridExportToExcelButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataGridRemoveButton creates a DataGridRemoveButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataGridRemoveButton() *DataGridRemoveButton { + o := &DataGridRemoveButton{} + o.SetTypeName("Forms$DataGridRemoveButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, }) + return o +} + +// NewDataGridRemoveButton creates a new DataGridRemoveButton for user code. Marked dirty (bit 63 = new element). +func NewDataGridRemoveButton() *DataGridRemoveButton { + o := initDataGridRemoveButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataView creates a DataView with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataView() *DataView { + o := &DataView{} + o.SetTypeName("Forms$DataView") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.dataSource = property.NewPart[element.Element]("DataSource") + o.dataSource.Bind(&o.Base, 7) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 8) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 9) + o.footerWidget = property.NewPart[element.Element]("FooterWidget") + o.footerWidget.Bind(&o.Base, 10) + o.footerWidgets = property.NewPartList[element.Element]("FooterWidgets") + o.footerWidgets.Bind(&o.Base, 11) + o.editable = property.NewPrimitive[bool]("Editable", property.DecodeBool) + o.editable.Bind(&o.Base, 12) + o.editability = property.NewEnum[string]("Editability") + o.editability.Bind(&o.Base, 13) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 14) + o.showControlBar = property.NewPrimitive[bool]("ShowControlBar", property.DecodeBool) + o.showControlBar.Bind(&o.Base, 15) + o.showFooter = property.NewPrimitive[bool]("ShowFooter", property.DecodeBool) + o.showFooter.Bind(&o.Base, 16) + o.closeOnSaveOrCancel = property.NewPrimitive[bool]("CloseOnSaveOrCancel", property.DecodeBool) + o.closeOnSaveOrCancel.Bind(&o.Base, 17) + o.useSchema = property.NewPrimitive[bool]("UseSchema", property.DecodeBool) + o.useSchema.Bind(&o.Base, 18) + o.noEntityMessage = property.NewPart[element.Element]("NoEntityMessage") + o.noEntityMessage.Bind(&o.Base, 19) + o.labelWidth = property.NewPrimitive[int32]("LabelWidth", property.DecodeInt32) + o.labelWidth.Bind(&o.Base, 20) + o.controlBar = property.NewPart[element.Element]("ControlBar") + o.controlBar.Bind(&o.Base, 21) + o.readOnlyStyle = property.NewEnum[string]("ReadOnlyStyle") + o.readOnlyStyle.Bind(&o.Base, 22) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.dataSource, o.widget, o.widgets, o.footerWidget, o.footerWidgets, o.editable, o.editability, o.conditionalEditabilitySettings, o.showControlBar, o.showFooter, o.closeOnSaveOrCancel, o.useSchema, o.noEntityMessage, o.labelWidth, o.controlBar, o.readOnlyStyle, }) + return o +} + +// NewDataView creates a new DataView for user code. Marked dirty (bit 63 = new element). +func NewDataView() *DataView { + o := initDataView() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataViewActionButton creates a DataViewActionButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataViewActionButton() *DataViewActionButton { + o := &DataViewActionButton{} + o.SetTypeName("Forms$DataViewActionButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 9) + o.action = property.NewPart[element.Element]("Action") + o.action.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.tabIndex, o.action, }) + return o +} + +// NewDataViewActionButton creates a new DataViewActionButton for user code. Marked dirty (bit 63 = new element). +func NewDataViewActionButton() *DataViewActionButton { + o := initDataViewActionButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataViewCancelButton creates a DataViewCancelButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataViewCancelButton() *DataViewCancelButton { + o := &DataViewCancelButton{} + o.SetTypeName("Forms$DataViewCancelButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.tabIndex, }) + return o +} + +// NewDataViewCancelButton creates a new DataViewCancelButton for user code. Marked dirty (bit 63 = new element). +func NewDataViewCancelButton() *DataViewCancelButton { + o := initDataViewCancelButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataViewCloseButton creates a DataViewCloseButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataViewCloseButton() *DataViewCloseButton { + o := &DataViewCloseButton{} + o.SetTypeName("Forms$DataViewCloseButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.tabIndex, }) + return o +} + +// NewDataViewCloseButton creates a new DataViewCloseButton for user code. Marked dirty (bit 63 = new element). +func NewDataViewCloseButton() *DataViewCloseButton { + o := initDataViewCloseButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataViewControlBar creates a DataViewControlBar with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataViewControlBar() *DataViewControlBar { + o := &DataViewControlBar{} + o.SetTypeName("Forms$DataViewControlBar") + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 0) + o.closeButton = property.NewByIdRef[element.Element]("CloseButton") + o.closeButton.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.items, o.closeButton, }) + return o +} + +// NewDataViewControlBar creates a new DataViewControlBar for user code. Marked dirty (bit 63 = new element). +func NewDataViewControlBar() *DataViewControlBar { + o := initDataViewControlBar() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataViewSaveButton creates a DataViewSaveButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataViewSaveButton() *DataViewSaveButton { + o := &DataViewSaveButton{} + o.SetTypeName("Forms$DataViewSaveButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 9) + o.syncAutomatically = property.NewPrimitive[bool]("SyncAutomatically", property.DecodeBool) + o.syncAutomatically.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.tabIndex, o.syncAutomatically, }) + return o +} + +// NewDataViewSaveButton creates a new DataViewSaveButton for user code. Marked dirty (bit 63 = new element). +func NewDataViewSaveButton() *DataViewSaveButton { + o := initDataViewSaveButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataViewSource creates a DataViewSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataViewSource() *DataViewSource { + o := &DataViewSource{} + o.SetTypeName("Forms$DataViewSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.pageParameter = property.NewByNameRef[element.Element]("PageParameter", "Forms$PageParameter") + o.pageParameter.Bind(&o.Base, 4) + o.snippetParameter = property.NewByNameRef[element.Element]("SnippetParameter", "Forms$SnippetParameter") + o.snippetParameter.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, o.pageParameter, o.snippetParameter, }) + return o +} + +// NewDataViewSource creates a new DataViewSource for user code. Marked dirty (bit 63 = new element). +func NewDataViewSource() *DataViewSource { + o := initDataViewSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDatabaseConstraint creates a DatabaseConstraint with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDatabaseConstraint() *DatabaseConstraint { + o := &DatabaseConstraint{} + o.SetTypeName("Forms$DatabaseConstraint") + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 0) + o.operator = property.NewEnum[string]("Operator") + o.operator.Bind(&o.Base, 1) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.attribute, o.operator, o.value, }) + return o +} + +// NewDatabaseConstraint creates a new DatabaseConstraint for user code. Marked dirty (bit 63 = new element). +func NewDatabaseConstraint() *DatabaseConstraint { + o := initDatabaseConstraint() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDatePicker creates a DatePicker with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDatePicker() *DatePicker { + o := &DatePicker{} + o.SetTypeName("Forms$DatePicker") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 7) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 8) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 9) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 10) + o.screenReaderLabel = property.NewPart[element.Element]("ScreenReaderLabel") + o.screenReaderLabel.Bind(&o.Base, 11) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 12) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 13) + o.readOnlyStyle = property.NewEnum[string]("ReadOnlyStyle") + o.readOnlyStyle.Bind(&o.Base, 14) + o.required = property.NewPrimitive[bool]("Required", property.DecodeBool) + o.required.Bind(&o.Base, 15) + o.requiredMessage = property.NewPart[element.Element]("RequiredMessage") + o.requiredMessage.Bind(&o.Base, 16) + o.validation = property.NewPart[element.Element]("Validation") + o.validation.Bind(&o.Base, 17) + o.onChangeMicroflowSettings = property.NewPart[element.Element]("OnChangeMicroflowSettings") + o.onChangeMicroflowSettings.Bind(&o.Base, 18) + o.onEnterMicroflowSettings = property.NewPart[element.Element]("OnEnterMicroflowSettings") + o.onEnterMicroflowSettings.Bind(&o.Base, 19) + o.onLeaveMicroflowSettings = property.NewPart[element.Element]("OnLeaveMicroflowSettings") + o.onLeaveMicroflowSettings.Bind(&o.Base, 20) + o.onChangeAction = property.NewPart[element.Element]("OnChangeAction") + o.onChangeAction.Bind(&o.Base, 21) + o.onEnterAction = property.NewPart[element.Element]("OnEnterAction") + o.onEnterAction.Bind(&o.Base, 22) + o.onLeaveAction = property.NewPart[element.Element]("OnLeaveAction") + o.onLeaveAction.Bind(&o.Base, 23) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 24) + o.ariaRequired = property.NewPrimitive[bool]("AriaRequired", property.DecodeBool) + o.ariaRequired.Bind(&o.Base, 25) + o.placeholder = property.NewPart[element.Element]("Placeholder") + o.placeholder.Bind(&o.Base, 26) + o.placeholderTemplate = property.NewPart[element.Element]("PlaceholderTemplate") + o.placeholderTemplate.Bind(&o.Base, 27) + o.formattingInfo = property.NewPart[element.Element]("FormattingInfo") + o.formattingInfo.Bind(&o.Base, 28) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 29) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.conditionalEditabilitySettings, o.editable, o.label, o.labelTemplate, o.screenReaderLabel, o.attributePath, o.attributeRef, o.readOnlyStyle, o.required, o.requiredMessage, o.validation, o.onChangeMicroflowSettings, o.onEnterMicroflowSettings, o.onLeaveMicroflowSettings, o.onChangeAction, o.onEnterAction, o.onLeaveAction, o.sourceVariable, o.ariaRequired, o.placeholder, o.placeholderTemplate, o.formattingInfo, o.nativeAccessibilitySettings, }) + return o +} + +// NewDatePicker creates a new DatePicker for user code. Marked dirty (bit 63 = new element). +func NewDatePicker() *DatePicker { + o := initDatePicker() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDeleteClientAction creates a DeleteClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDeleteClientAction() *DeleteClientAction { + o := &DeleteClientAction{} + o.SetTypeName("Forms$DeleteClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.closePage = property.NewPrimitive[bool]("ClosePage", property.DecodeBool) + o.closePage.Bind(&o.Base, 1) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.closePage, o.sourceVariable, }) + return o +} + +// NewDeleteClientAction creates a new DeleteClientAction for user code. Marked dirty (bit 63 = new element). +func NewDeleteClientAction() *DeleteClientAction { + o := initDeleteClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDesignPropertyValue creates a DesignPropertyValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDesignPropertyValue() *DesignPropertyValue { + o := &DesignPropertyValue{} + o.SetTypeName("Forms$DesignPropertyValue") + o.key = property.NewPrimitive[string]("Key", property.DecodeString) + o.key.Bind(&o.Base, 0) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 1) + o.stringValue = property.NewPrimitive[string]("StringValue", property.DecodeString) + o.stringValue.Bind(&o.Base, 2) + o.booleanValue = property.NewPrimitive[bool]("BooleanValue", property.DecodeBool) + o.booleanValue.Bind(&o.Base, 3) + o.value = property.NewPart[element.Element]("Value") + o.value.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.key, o.propType, o.stringValue, o.booleanValue, o.value, }) + return o +} + +// NewDesignPropertyValue creates a new DesignPropertyValue for user code. Marked dirty (bit 63 = new element). +func NewDesignPropertyValue() *DesignPropertyValue { + o := initDesignPropertyValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDivContainer creates a DivContainer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDivContainer() *DivContainer { + o := &DivContainer{} + o.SetTypeName("Forms$DivContainer") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 7) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 8) + o.renderMode = property.NewEnum[string]("RenderMode") + o.renderMode.Bind(&o.Base, 9) + o.onClickAction = property.NewPart[element.Element]("OnClickAction") + o.onClickAction.Bind(&o.Base, 10) + o.screenReaderHidden = property.NewPrimitive[bool]("ScreenReaderHidden", property.DecodeBool) + o.screenReaderHidden.Bind(&o.Base, 11) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.widget, o.widgets, o.renderMode, o.onClickAction, o.screenReaderHidden, o.nativeAccessibilitySettings, }) + return o +} + +// NewDivContainer creates a new DivContainer for user code. Marked dirty (bit 63 = new element). +func NewDivContainer() *DivContainer { + o := initDivContainer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDropDown creates a DropDown with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDropDown() *DropDown { + o := &DropDown{} + o.SetTypeName("Forms$DropDown") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 7) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 8) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 9) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 10) + o.screenReaderLabel = property.NewPart[element.Element]("ScreenReaderLabel") + o.screenReaderLabel.Bind(&o.Base, 11) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 12) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 13) + o.readOnlyStyle = property.NewEnum[string]("ReadOnlyStyle") + o.readOnlyStyle.Bind(&o.Base, 14) + o.required = property.NewPrimitive[bool]("Required", property.DecodeBool) + o.required.Bind(&o.Base, 15) + o.requiredMessage = property.NewPart[element.Element]("RequiredMessage") + o.requiredMessage.Bind(&o.Base, 16) + o.validation = property.NewPart[element.Element]("Validation") + o.validation.Bind(&o.Base, 17) + o.onChangeMicroflowSettings = property.NewPart[element.Element]("OnChangeMicroflowSettings") + o.onChangeMicroflowSettings.Bind(&o.Base, 18) + o.onEnterMicroflowSettings = property.NewPart[element.Element]("OnEnterMicroflowSettings") + o.onEnterMicroflowSettings.Bind(&o.Base, 19) + o.onLeaveMicroflowSettings = property.NewPart[element.Element]("OnLeaveMicroflowSettings") + o.onLeaveMicroflowSettings.Bind(&o.Base, 20) + o.onChangeAction = property.NewPart[element.Element]("OnChangeAction") + o.onChangeAction.Bind(&o.Base, 21) + o.onEnterAction = property.NewPart[element.Element]("OnEnterAction") + o.onEnterAction.Bind(&o.Base, 22) + o.onLeaveAction = property.NewPart[element.Element]("OnLeaveAction") + o.onLeaveAction.Bind(&o.Base, 23) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 24) + o.ariaRequired = property.NewPrimitive[bool]("AriaRequired", property.DecodeBool) + o.ariaRequired.Bind(&o.Base, 25) + o.emptyOptionCaption = property.NewPart[element.Element]("EmptyOptionCaption") + o.emptyOptionCaption.Bind(&o.Base, 26) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 27) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.conditionalEditabilitySettings, o.editable, o.label, o.labelTemplate, o.screenReaderLabel, o.attributePath, o.attributeRef, o.readOnlyStyle, o.required, o.requiredMessage, o.validation, o.onChangeMicroflowSettings, o.onEnterMicroflowSettings, o.onLeaveMicroflowSettings, o.onChangeAction, o.onEnterAction, o.onLeaveAction, o.sourceVariable, o.ariaRequired, o.emptyOptionCaption, o.nativeAccessibilitySettings, }) + return o +} + +// NewDropDown creates a new DropDown for user code. Marked dirty (bit 63 = new element). +func NewDropDown() *DropDown { + o := initDropDown() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDropDownButton creates a DropDownButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDropDownButton() *DropDownButton { + o := &DropDownButton{} + o.SetTypeName("Forms$DropDownButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, o.items, }) + return o +} + +// NewDropDownButton creates a new DropDownButton for user code. Marked dirty (bit 63 = new element). +func NewDropDownButton() *DropDownButton { + o := initDropDownButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDropDownButtonItem creates a DropDownButtonItem with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDropDownButtonItem() *DropDownButtonItem { + o := &DropDownButtonItem{} + o.SetTypeName("Forms$DropDownButtonItem") + o.action = property.NewPart[element.Element]("Action") + o.action.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.image = property.NewByNameRef[element.Element]("Image", "Images$Image") + o.image.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.action, o.caption, o.image, }) + return o +} + +// NewDropDownButtonItem creates a new DropDownButtonItem for user code. Marked dirty (bit 63 = new element). +func NewDropDownButtonItem() *DropDownButtonItem { + o := initDropDownButtonItem() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDropDownSearchField creates a DropDownSearchField with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDropDownSearchField() *DropDownSearchField { + o := &DropDownSearchField{} + o.SetTypeName("Forms$DropDownSearchField") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.placeholder = property.NewPart[element.Element]("Placeholder") + o.placeholder.Bind(&o.Base, 2) + o.customDateFormat = property.NewPrimitive[string]("CustomDateFormat", property.DecodeString) + o.customDateFormat.Bind(&o.Base, 3) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 4) + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 5) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 6) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 7) + o.operator = property.NewEnum[string]("Operator") + o.operator.Bind(&o.Base, 8) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 9) + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 10) + o.allowMultipleSelect = property.NewPrimitive[bool]("AllowMultipleSelect", property.DecodeBool) + o.allowMultipleSelect.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.caption, o.placeholder, o.customDateFormat, o.propType, o.defaultValue, o.attributePath, o.attributeRef, o.operator, o.sortBar, o.xPathConstraint, o.allowMultipleSelect, }) + return o +} + +// NewDropDownSearchField creates a new DropDownSearchField for user code. Marked dirty (bit 63 = new element). +func NewDropDownSearchField() *DropDownSearchField { + o := initDropDownSearchField() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDynamicImageViewer creates a DynamicImageViewer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDynamicImageViewer() *DynamicImageViewer { + o := &DynamicImageViewer{} + o.SetTypeName("Forms$ImageViewer") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.dataSource = property.NewPart[element.Element]("DataSource") + o.dataSource.Bind(&o.Base, 7) + o.defaultImage = property.NewByNameRef[element.Element]("DefaultImage", "Images$Image") + o.defaultImage.Bind(&o.Base, 8) + o.widthUnit = property.NewEnum[string]("WidthUnit") + o.widthUnit.Bind(&o.Base, 9) + o.heightUnit = property.NewEnum[string]("HeightUnit") + o.heightUnit.Bind(&o.Base, 10) + o.width = property.NewPrimitive[int32]("Width", property.DecodeInt32) + o.width.Bind(&o.Base, 11) + o.height = property.NewPrimitive[int32]("Height", property.DecodeInt32) + o.height.Bind(&o.Base, 12) + o.responsive = property.NewPrimitive[bool]("Responsive", property.DecodeBool) + o.responsive.Bind(&o.Base, 13) + o.showAsThumbnail = property.NewPrimitive[bool]("ShowAsThumbnail", property.DecodeBool) + o.showAsThumbnail.Bind(&o.Base, 14) + o.onClickBehavior = property.NewPart[element.Element]("OnClickBehavior") + o.onClickBehavior.Bind(&o.Base, 15) + o.clickAction = property.NewPart[element.Element]("ClickAction") + o.clickAction.Bind(&o.Base, 16) + o.onClickEnlarge = property.NewPrimitive[bool]("OnClickEnlarge", property.DecodeBool) + o.onClickEnlarge.Bind(&o.Base, 17) + o.alternativeText = property.NewPart[element.Element]("AlternativeText") + o.alternativeText.Bind(&o.Base, 18) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 19) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.dataSource, o.defaultImage, o.widthUnit, o.heightUnit, o.width, o.height, o.responsive, o.showAsThumbnail, o.onClickBehavior, o.clickAction, o.onClickEnlarge, o.alternativeText, o.nativeAccessibilitySettings, }) + return o +} + +// NewDynamicImageViewer creates a new DynamicImageViewer for user code. Marked dirty (bit 63 = new element). +func NewDynamicImageViewer() *DynamicImageViewer { + o := initDynamicImageViewer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDynamicText creates a DynamicText with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDynamicText() *DynamicText { + o := &DynamicText{} + o.SetTypeName("Forms$DynamicText") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.content = property.NewPart[element.Element]("Content") + o.content.Bind(&o.Base, 7) + o.renderMode = property.NewEnum[string]("RenderMode") + o.renderMode.Bind(&o.Base, 8) + o.nativeTextStyle = property.NewEnum[string]("NativeTextStyle") + o.nativeTextStyle.Bind(&o.Base, 9) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.content, o.renderMode, o.nativeTextStyle, o.nativeAccessibilitySettings, }) + return o +} + +// NewDynamicText creates a new DynamicText for user code. Marked dirty (bit 63 = new element). +func NewDynamicText() *DynamicText { + o := initDynamicText() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEditPageTemplateType creates a EditPageTemplateType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEditPageTemplateType() *EditPageTemplateType { + o := &EditPageTemplateType{} + o.SetTypeName("Forms$EditPageTemplateType") + o.SetProperties([]element.Property{}) + return o +} + +// NewEditPageTemplateType creates a new EditPageTemplateType for user code. Marked dirty (bit 63 = new element). +func NewEditPageTemplateType() *EditPageTemplateType { + o := initEditPageTemplateType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFileManager creates a FileManager with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFileManager() *FileManager { + o := &FileManager{} + o.SetTypeName("Forms$FileManager") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 7) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 8) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 9) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 10) + o.screenReaderLabel = property.NewPart[element.Element]("ScreenReaderLabel") + o.screenReaderLabel.Bind(&o.Base, 11) + o.allowedExtensions = property.NewPrimitive[string]("AllowedExtensions", property.DecodeString) + o.allowedExtensions.Bind(&o.Base, 12) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 13) + o.maxFileSize = property.NewPrimitive[int32]("MaxFileSize", property.DecodeInt32) + o.maxFileSize.Bind(&o.Base, 14) + o.showFileInBrowser = property.NewPrimitive[bool]("ShowFileInBrowser", property.DecodeBool) + o.showFileInBrowser.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.conditionalEditabilitySettings, o.editable, o.label, o.labelTemplate, o.screenReaderLabel, o.allowedExtensions, o.propType, o.maxFileSize, o.showFileInBrowser, }) + return o +} + +// NewFileManager creates a new FileManager for user code. Marked dirty (bit 63 = new element). +func NewFileManager() *FileManager { + o := initFileManager() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFormattingInfo creates a FormattingInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFormattingInfo() *FormattingInfo { + o := &FormattingInfo{} + o.SetTypeName("Forms$FormattingInfo") + o.decimalPrecision = property.NewPrimitive[int32]("DecimalPrecision", property.DecodeInt32) + o.decimalPrecision.Bind(&o.Base, 0) + o.groupDigits = property.NewPrimitive[bool]("GroupDigits", property.DecodeBool) + o.groupDigits.Bind(&o.Base, 1) + o.enumFormat = property.NewEnum[string]("EnumFormat") + o.enumFormat.Bind(&o.Base, 2) + o.dateFormat = property.NewEnum[string]("DateFormat") + o.dateFormat.Bind(&o.Base, 3) + o.customDateFormat = property.NewPrimitive[string]("CustomDateFormat", property.DecodeString) + o.customDateFormat.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.decimalPrecision, o.groupDigits, o.enumFormat, o.dateFormat, o.customDateFormat, }) + return o +} + +// NewFormattingInfo creates a new FormattingInfo for user code. Marked dirty (bit 63 = new element). +func NewFormattingInfo() *FormattingInfo { + o := initFormattingInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGlyphIcon creates a GlyphIcon with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGlyphIcon() *GlyphIcon { + o := &GlyphIcon{} + o.SetTypeName("Forms$GlyphIcon") + o.code = property.NewPrimitive[int32]("Code", property.DecodeInt32) + o.code.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.code, }) + return o +} + +// NewGlyphIcon creates a new GlyphIcon for user code. Marked dirty (bit 63 = new element). +func NewGlyphIcon() *GlyphIcon { + o := initGlyphIcon() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridActionButton creates a GridActionButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridActionButton() *GridActionButton { + o := &GridActionButton{} + o.SetTypeName("Forms$GridActionButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.action = property.NewPart[element.Element]("Action") + o.action.Bind(&o.Base, 9) + o.maintainSelectionAfterMicroflow = property.NewPrimitive[bool]("MaintainSelectionAfterMicroflow", property.DecodeBool) + o.maintainSelectionAfterMicroflow.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.action, o.maintainSelectionAfterMicroflow, }) + return o +} + +// NewGridActionButton creates a new GridActionButton for user code. Marked dirty (bit 63 = new element). +func NewGridActionButton() *GridActionButton { + o := initGridActionButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridColumn creates a GridColumn with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridColumn() *GridColumn { + o := &GridColumn{} + o.SetTypeName("Forms$GridColumn") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 2) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 3) + o.formattingInfo = property.NewPart[element.Element]("FormattingInfo") + o.formattingInfo.Bind(&o.Base, 4) + o.showTooltip = property.NewPrimitive[bool]("ShowTooltip", property.DecodeBool) + o.showTooltip.Bind(&o.Base, 5) + o.aggregateCaption = property.NewPart[element.Element]("AggregateCaption") + o.aggregateCaption.Bind(&o.Base, 6) + o.aggregateFunction = property.NewEnum[string]("AggregateFunction") + o.aggregateFunction.Bind(&o.Base, 7) + o.editable = property.NewPrimitive[bool]("Editable", property.DecodeBool) + o.editable.Bind(&o.Base, 8) + o.width = property.NewPrimitive[int32]("Width", property.DecodeInt32) + o.width.Bind(&o.Base, 9) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 10) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 11) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.caption, o.attributePath, o.attributeRef, o.formattingInfo, o.showTooltip, o.aggregateCaption, o.aggregateFunction, o.editable, o.width, o.class, o.style, o.appearance, }) + return o +} + +// NewGridColumn creates a new GridColumn for user code. Marked dirty (bit 63 = new element). +func NewGridColumn() *GridColumn { + o := initGridColumn() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridControlBar creates a GridControlBar with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridControlBar() *GridControlBar { + o := &GridControlBar{} + o.SetTypeName("Forms$GridControlBar") + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 0) + o.searchButton = property.NewPart[element.Element]("SearchButton") + o.searchButton.Bind(&o.Base, 1) + o.defaultButton = property.NewByIdRef[element.Element]("DefaultButtonPointer") + o.defaultButton.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.items, o.searchButton, o.defaultButton, }) + return o +} + +// NewGridControlBar creates a new GridControlBar for user code. Marked dirty (bit 63 = new element). +func NewGridControlBar() *GridControlBar { + o := initGridControlBar() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridDatabaseSource creates a GridDatabaseSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridDatabaseSource() *GridDatabaseSource { + o := &GridDatabaseSource{} + o.SetTypeName("Forms$GridDatabaseSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 4) + o.databaseConstraints = property.NewPartList[element.Element]("DatabaseConstraints") + o.databaseConstraints.Bind(&o.Base, 5) + o.searchBar = property.NewPart[element.Element]("SearchBar") + o.searchBar.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, o.sortBar, o.databaseConstraints, o.searchBar, }) + return o +} + +// NewGridDatabaseSource creates a new GridDatabaseSource for user code. Marked dirty (bit 63 = new element). +func NewGridDatabaseSource() *GridDatabaseSource { + o := initGridDatabaseSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridDeleteButton creates a GridDeleteButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridDeleteButton() *GridDeleteButton { + o := &GridDeleteButton{} + o.SetTypeName("Forms$GridDeleteButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, }) + return o +} + +// NewGridDeleteButton creates a new GridDeleteButton for user code. Marked dirty (bit 63 = new element). +func NewGridDeleteButton() *GridDeleteButton { + o := initGridDeleteButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridDeselectAllButton creates a GridDeselectAllButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridDeselectAllButton() *GridDeselectAllButton { + o := &GridDeselectAllButton{} + o.SetTypeName("Forms$GridDeselectAllButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, }) + return o +} + +// NewGridDeselectAllButton creates a new GridDeselectAllButton for user code. Marked dirty (bit 63 = new element). +func NewGridDeselectAllButton() *GridDeselectAllButton { + o := initGridDeselectAllButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridEditButton creates a GridEditButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridEditButton() *GridEditButton { + o := &GridEditButton{} + o.SetTypeName("Forms$GridEditButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.pageSettings = property.NewPart[element.Element]("PageSettings") + o.pageSettings.Bind(&o.Base, 9) + o.pagesForSpecializations = property.NewPartList[element.Element]("PagesForSpecializations") + o.pagesForSpecializations.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.pageSettings, o.pagesForSpecializations, }) + return o +} + +// NewGridEditButton creates a new GridEditButton for user code. Marked dirty (bit 63 = new element). +func NewGridEditButton() *GridEditButton { + o := initGridEditButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridNewButton creates a GridNewButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridNewButton() *GridNewButton { + o := &GridNewButton{} + o.SetTypeName("Forms$GridNewButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 9) + o.editLocation = property.NewEnum[string]("EditLocation") + o.editLocation.Bind(&o.Base, 10) + o.pageSettings = property.NewPart[element.Element]("PageSettings") + o.pageSettings.Bind(&o.Base, 11) + o.isPersistent = property.NewPrimitive[bool]("IsPersistent", property.DecodeBool) + o.isPersistent.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.entity, o.editLocation, o.pageSettings, o.isPersistent, }) + return o +} + +// NewGridNewButton creates a new GridNewButton for user code. Marked dirty (bit 63 = new element). +func NewGridNewButton() *GridNewButton { + o := initGridNewButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridSearchButton creates a GridSearchButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridSearchButton() *GridSearchButton { + o := &GridSearchButton{} + o.SetTypeName("Forms$GridSearchButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, }) + return o +} + +// NewGridSearchButton creates a new GridSearchButton for user code. Marked dirty (bit 63 = new element). +func NewGridSearchButton() *GridSearchButton { + o := initGridSearchButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridSelectAllButton creates a GridSelectAllButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridSelectAllButton() *GridSelectAllButton { + o := &GridSelectAllButton{} + o.SetTypeName("Forms$GridSelectAllButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.selectionType = property.NewEnum[string]("SelectionType") + o.selectionType.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, o.selectionType, }) + return o +} + +// NewGridSelectAllButton creates a new GridSelectAllButton for user code. Marked dirty (bit 63 = new element). +func NewGridSelectAllButton() *GridSelectAllButton { + o := initGridSelectAllButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridSortBar creates a GridSortBar with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridSortBar() *GridSortBar { + o := &GridSortBar{} + o.SetTypeName("Forms$GridSortBar") + o.sortItems = property.NewPartList[element.Element]("SortItems") + o.sortItems.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.sortItems, }) + return o +} + +// NewGridSortBar creates a new GridSortBar for user code. Marked dirty (bit 63 = new element). +func NewGridSortBar() *GridSortBar { + o := initGridSortBar() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridSortItem creates a GridSortItem with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridSortItem() *GridSortItem { + o := &GridSortItem{} + o.SetTypeName("Forms$GridSortItem") + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 0) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 1) + o.sortDirection = property.NewEnum[string]("SortDirection") + o.sortDirection.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.attributePath, o.attributeRef, o.sortDirection, }) + return o +} + +// NewGridSortItem creates a new GridSortItem for user code. Marked dirty (bit 63 = new element). +func NewGridSortItem() *GridSortItem { + o := initGridSortItem() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGridXPathSource creates a GridXPathSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGridXPathSource() *GridXPathSource { + o := &GridXPathSource{} + o.SetTypeName("Forms$GridXPathSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 4) + o.searchBar = property.NewPart[element.Element]("SearchBar") + o.searchBar.Bind(&o.Base, 5) + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 6) + o.applyContext = property.NewPrimitive[bool]("ApplyContext", property.DecodeBool) + o.applyContext.Bind(&o.Base, 7) + o.removeAllFromContext = property.NewPrimitive[bool]("RemoveAllFromContext", property.DecodeBool) + o.removeAllFromContext.Bind(&o.Base, 8) + o.removeFromContextIds = property.NewByNameRefList[element.Element]("RemoveFromContextIds", "DomainModels$Entity") + o.removeFromContextIds.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, o.sortBar, o.searchBar, o.xPathConstraint, o.applyContext, o.removeAllFromContext, o.removeFromContextIds, }) + return o +} + +// NewGridXPathSource creates a new GridXPathSource for user code. Marked dirty (bit 63 = new element). +func NewGridXPathSource() *GridXPathSource { + o := initGridXPathSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initGroupBox creates a GroupBox with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initGroupBox() *GroupBox { + o := &GroupBox{} + o.SetTypeName("Forms$GroupBox") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.collapsible = property.NewEnum[string]("Collapsible") + o.collapsible.Bind(&o.Base, 8) + o.headerMode = property.NewEnum[string]("HeaderMode") + o.headerMode.Bind(&o.Base, 9) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 10) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.collapsible, o.headerMode, o.widget, o.widgets, }) + return o +} + +// NewGroupBox creates a new GroupBox for user code. Marked dirty (bit 63 = new element). +func NewGroupBox() *GroupBox { + o := initGroupBox() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initHeader creates a Header with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initHeader() *Header { + o := &Header{} + o.SetTypeName("Forms$Header") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.leftWidget = property.NewPart[element.Element]("LeftWidget") + o.leftWidget.Bind(&o.Base, 5) + o.leftWidgets = property.NewPartList[element.Element]("LeftWidgets") + o.leftWidgets.Bind(&o.Base, 6) + o.rightWidget = property.NewPart[element.Element]("RightWidget") + o.rightWidget.Bind(&o.Base, 7) + o.rightWidgets = property.NewPartList[element.Element]("RightWidgets") + o.rightWidgets.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.leftWidget, o.leftWidgets, o.rightWidget, o.rightWidgets, }) + return o +} + +// NewHeader creates a new Header for user code. Marked dirty (bit 63 = new element). +func NewHeader() *Header { + o := initHeader() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initHorizontalSplitPane creates a HorizontalSplitPane with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initHorizontalSplitPane() *HorizontalSplitPane { + o := &HorizontalSplitPane{} + o.SetTypeName("Forms$HorizontalSplitPane") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.firstWidget = property.NewPart[element.Element]("FirstWidget") + o.firstWidget.Bind(&o.Base, 5) + o.secondWidget = property.NewPart[element.Element]("SecondWidget") + o.secondWidget.Bind(&o.Base, 6) + o.firstWidgets = property.NewPartList[element.Element]("FirstWidgets") + o.firstWidgets.Bind(&o.Base, 7) + o.secondWidgets = property.NewPartList[element.Element]("SecondWidgets") + o.secondWidgets.Bind(&o.Base, 8) + o.animatedResize = property.NewPrimitive[bool]("AnimatedResize", property.DecodeBool) + o.animatedResize.Bind(&o.Base, 9) + o.height = property.NewPrimitive[int32]("Height", property.DecodeInt32) + o.height.Bind(&o.Base, 10) + o.position = property.NewPrimitive[int32]("Position", property.DecodeInt32) + o.position.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.firstWidget, o.secondWidget, o.firstWidgets, o.secondWidgets, o.animatedResize, o.height, o.position, }) + return o +} + +// NewHorizontalSplitPane creates a new HorizontalSplitPane for user code. Marked dirty (bit 63 = new element). +func NewHorizontalSplitPane() *HorizontalSplitPane { + o := initHorizontalSplitPane() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIconCollectionIcon creates a IconCollectionIcon with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIconCollectionIcon() *IconCollectionIcon { + o := &IconCollectionIcon{} + o.SetTypeName("Forms$IconCollectionIcon") + o.image = property.NewByNameRef[element.Element]("Image", "CustomIcons$CustomIcon") + o.image.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.image, }) + return o +} + +// NewIconCollectionIcon creates a new IconCollectionIcon for user code. Marked dirty (bit 63 = new element). +func NewIconCollectionIcon() *IconCollectionIcon { + o := initIconCollectionIcon() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImageIcon creates a ImageIcon with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImageIcon() *ImageIcon { + o := &ImageIcon{} + o.SetTypeName("Forms$ImageIcon") + o.image = property.NewByNameRef[element.Element]("Image", "Images$Image") + o.image.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.image, }) + return o +} + +// NewImageIcon creates a new ImageIcon for user code. Marked dirty (bit 63 = new element). +func NewImageIcon() *ImageIcon { + o := initImageIcon() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImageUploader creates a ImageUploader with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImageUploader() *ImageUploader { + o := &ImageUploader{} + o.SetTypeName("Forms$ImageUploader") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 7) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 8) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 9) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 10) + o.screenReaderLabel = property.NewPart[element.Element]("ScreenReaderLabel") + o.screenReaderLabel.Bind(&o.Base, 11) + o.allowedExtensions = property.NewPrimitive[string]("AllowedExtensions", property.DecodeString) + o.allowedExtensions.Bind(&o.Base, 12) + o.thumbnailSize = property.NewPrimitive[string]("ThumbnailSize", property.DecodeString) + o.thumbnailSize.Bind(&o.Base, 13) + o.maxFileSize = property.NewPrimitive[int32]("MaxFileSize", property.DecodeInt32) + o.maxFileSize.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.conditionalEditabilitySettings, o.editable, o.label, o.labelTemplate, o.screenReaderLabel, o.allowedExtensions, o.thumbnailSize, o.maxFileSize, }) + return o +} + +// NewImageUploader creates a new ImageUploader for user code. Marked dirty (bit 63 = new element). +func NewImageUploader() *ImageUploader { + o := initImageUploader() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImageViewerSource creates a ImageViewerSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImageViewerSource() *ImageViewerSource { + o := &ImageViewerSource{} + o.SetTypeName("Forms$ImageViewerSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, }) + return o +} + +// NewImageViewerSource creates a new ImageViewerSource for user code. Marked dirty (bit 63 = new element). +func NewImageViewerSource() *ImageViewerSource { + o := initImageViewerSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initInputReferenceSetSelector creates a InputReferenceSetSelector with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initInputReferenceSetSelector() *InputReferenceSetSelector { + o := &InputReferenceSetSelector{} + o.SetTypeName("Forms$InputReferenceSetSelector") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 7) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 8) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 9) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 10) + o.screenReaderLabel = property.NewPart[element.Element]("ScreenReaderLabel") + o.screenReaderLabel.Bind(&o.Base, 11) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 12) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 13) + o.readOnlyStyle = property.NewEnum[string]("ReadOnlyStyle") + o.readOnlyStyle.Bind(&o.Base, 14) + o.selectorSource = property.NewPart[element.Element]("SelectorSource") + o.selectorSource.Bind(&o.Base, 15) + o.selectPageSettings = property.NewPart[element.Element]("SelectPageSettings") + o.selectPageSettings.Bind(&o.Base, 16) + o.onChangeMicroflowSettings = property.NewPart[element.Element]("OnChangeMicroflowSettings") + o.onChangeMicroflowSettings.Bind(&o.Base, 17) + o.onChangeAction = property.NewPart[element.Element]("OnChangeAction") + o.onChangeAction.Bind(&o.Base, 18) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 19) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.conditionalEditabilitySettings, o.editable, o.label, o.labelTemplate, o.screenReaderLabel, o.attributePath, o.attributeRef, o.readOnlyStyle, o.selectorSource, o.selectPageSettings, o.onChangeMicroflowSettings, o.onChangeAction, o.sourceVariable, }) + return o +} + +// NewInputReferenceSetSelector creates a new InputReferenceSetSelector for user code. Marked dirty (bit 63 = new element). +func NewInputReferenceSetSelector() *InputReferenceSetSelector { + o := initInputReferenceSetSelector() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLabel creates a Label with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLabel() *Label { + o := &Label{} + o.SetTypeName("Forms$Label") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, }) + return o +} + +// NewLabel creates a new Label for user code. Marked dirty (bit 63 = new element). +func NewLabel() *Label { + o := initLabel() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLayout creates a Layout with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLayout() *Layout { + o := &Layout{} + o.SetTypeName("Forms$Layout") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.canvasWidth = property.NewPrimitive[int32]("CanvasWidth", property.DecodeInt32) + o.canvasWidth.Bind(&o.Base, 4) + o.canvasHeight = property.NewPrimitive[int32]("CanvasHeight", property.DecodeInt32) + o.canvasHeight.Bind(&o.Base, 5) + o.content = property.NewPart[element.Element]("Content") + o.content.Bind(&o.Base, 6) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 7) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 8) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 9) + o.layoutCall = property.NewPart[element.Element]("LayoutCall") + o.layoutCall.Bind(&o.Base, 10) + o.layoutType = property.NewEnum[string]("LayoutType") + o.layoutType.Bind(&o.Base, 11) + o.mainPlaceholder = property.NewByNameRef[element.Element]("MainPlaceholder", "Forms$LayoutParameter") + o.mainPlaceholder.Bind(&o.Base, 12) + o.acceptButtonPlaceholder = property.NewByNameRef[element.Element]("AcceptButtonPlaceholder", "Forms$LayoutParameter") + o.acceptButtonPlaceholder.Bind(&o.Base, 13) + o.cancelButtonPlaceholder = property.NewByNameRef[element.Element]("CancelButtonPlaceholder", "Forms$LayoutParameter") + o.cancelButtonPlaceholder.Bind(&o.Base, 14) + o.mainPlaceholderName = property.NewPrimitive[string]("MainPlaceholderName", property.DecodeString) + o.mainPlaceholderName.Bind(&o.Base, 15) + o.acceptPlaceholderName = property.NewPrimitive[string]("AcceptPlaceholderName", property.DecodeString) + o.acceptPlaceholderName.Bind(&o.Base, 16) + o.cancelPlaceholderName = property.NewPrimitive[string]("CancelPlaceholderName", property.DecodeString) + o.cancelPlaceholderName.Bind(&o.Base, 17) + o.useMainPlaceholderForPopups = property.NewPrimitive[bool]("UseMainPlaceholderForPopups", property.DecodeBool) + o.useMainPlaceholderForPopups.Bind(&o.Base, 18) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 19) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 20) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.canvasWidth, o.canvasHeight, o.content, o.appearance, o.widget, o.widgets, o.layoutCall, o.layoutType, o.mainPlaceholder, o.acceptButtonPlaceholder, o.cancelButtonPlaceholder, o.mainPlaceholderName, o.acceptPlaceholderName, o.cancelPlaceholderName, o.useMainPlaceholderForPopups, o.class, o.style, }) + return o +} + +// NewLayout creates a new Layout for user code. Marked dirty (bit 63 = new element). +func NewLayout() *Layout { + o := initLayout() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLayoutCall creates a LayoutCall with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLayoutCall() *LayoutCall { + o := &LayoutCall{} + o.SetTypeName("Forms$LayoutCall") + o.layout = property.NewByNameRef[element.Element]("Layout", "Forms$Layout") + o.layout.Bind(&o.Base, 0) + o.arguments = property.NewPartList[element.Element]("Arguments") + o.arguments.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.layout, o.arguments, }) + return o +} + +// NewLayoutCall creates a new LayoutCall for user code. Marked dirty (bit 63 = new element). +func NewLayoutCall() *LayoutCall { + o := initLayoutCall() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLayoutCallArgument creates a LayoutCallArgument with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLayoutCallArgument() *LayoutCallArgument { + o := &LayoutCallArgument{} + o.SetTypeName("Forms$LayoutCallArgument") + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 0) + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Forms$LayoutParameter") + o.parameter.Bind(&o.Base, 1) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 2) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.parameterName, o.parameter, o.widget, o.widgets, }) + return o +} + +// NewLayoutCallArgument creates a new LayoutCallArgument for user code. Marked dirty (bit 63 = new element). +func NewLayoutCallArgument() *LayoutCallArgument { + o := initLayoutCallArgument() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLayoutGrid creates a LayoutGrid with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLayoutGrid() *LayoutGrid { + o := &LayoutGrid{} + o.SetTypeName("Forms$LayoutGrid") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.width = property.NewEnum[string]("Width") + o.width.Bind(&o.Base, 7) + o.rows = property.NewPartList[element.Element]("Rows") + o.rows.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.width, o.rows, }) + return o +} + +// NewLayoutGrid creates a new LayoutGrid for user code. Marked dirty (bit 63 = new element). +func NewLayoutGrid() *LayoutGrid { + o := initLayoutGrid() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLayoutGridColumn creates a LayoutGridColumn with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLayoutGridColumn() *LayoutGridColumn { + o := &LayoutGridColumn{} + o.SetTypeName("Forms$LayoutGridColumn") + o.weight = property.NewPrimitive[int32]("Weight", property.DecodeInt32) + o.weight.Bind(&o.Base, 0) + o.tabletWeight = property.NewPrimitive[int32]("TabletWeight", property.DecodeInt32) + o.tabletWeight.Bind(&o.Base, 1) + o.phoneWeight = property.NewPrimitive[int32]("PhoneWeight", property.DecodeInt32) + o.phoneWeight.Bind(&o.Base, 2) + o.previewWidth = property.NewPrimitive[int32]("PreviewWidth", property.DecodeInt32) + o.previewWidth.Bind(&o.Base, 3) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 4) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 5) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 6) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 7) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 8) + o.verticalAlignment = property.NewEnum[string]("VerticalAlignment") + o.verticalAlignment.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.weight, o.tabletWeight, o.phoneWeight, o.previewWidth, o.widget, o.widgets, o.class, o.style, o.appearance, o.verticalAlignment, }) + return o +} + +// NewLayoutGridColumn creates a new LayoutGridColumn for user code. Marked dirty (bit 63 = new element). +func NewLayoutGridColumn() *LayoutGridColumn { + o := initLayoutGridColumn() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLayoutGridRow creates a LayoutGridRow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLayoutGridRow() *LayoutGridRow { + o := &LayoutGridRow{} + o.SetTypeName("Forms$LayoutGridRow") + o.columns = property.NewPartList[element.Element]("Columns") + o.columns.Bind(&o.Base, 0) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 1) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 2) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 3) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 4) + o.verticalAlignment = property.NewEnum[string]("VerticalAlignment") + o.verticalAlignment.Bind(&o.Base, 5) + o.horizontalAlignment = property.NewEnum[string]("HorizontalAlignment") + o.horizontalAlignment.Bind(&o.Base, 6) + o.spacingBetweenColumns = property.NewPrimitive[bool]("SpacingBetweenColumns", property.DecodeBool) + o.spacingBetweenColumns.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.columns, o.conditionalVisibilitySettings, o.class, o.style, o.appearance, o.verticalAlignment, o.horizontalAlignment, o.spacingBetweenColumns, }) + return o +} + +// NewLayoutGridRow creates a new LayoutGridRow for user code. Marked dirty (bit 63 = new element). +func NewLayoutGridRow() *LayoutGridRow { + o := initLayoutGridRow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLinkButton creates a LinkButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLinkButton() *LinkButton { + o := &LinkButton{} + o.SetTypeName("Forms$LinkButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.linkType = property.NewEnum[string]("LinkType") + o.linkType.Bind(&o.Base, 12) + o.address = property.NewPart[element.Element]("Address") + o.address.Bind(&o.Base, 13) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, o.linkType, o.address, }) + return o +} + +// NewLinkButton creates a new LinkButton for user code. Marked dirty (bit 63 = new element). +func NewLinkButton() *LinkButton { + o := initLinkButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListView creates a ListView with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListView() *ListView { + o := &ListView{} + o.SetTypeName("Forms$ListView") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.dataSource = property.NewPart[element.Element]("DataSource") + o.dataSource.Bind(&o.Base, 7) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 8) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 9) + o.pageSize = property.NewPrimitive[int32]("PageSize", property.DecodeInt32) + o.pageSize.Bind(&o.Base, 10) + o.clickAction = property.NewPart[element.Element]("ClickAction") + o.clickAction.Bind(&o.Base, 11) + o.editable = property.NewPrimitive[bool]("Editable", property.DecodeBool) + o.editable.Bind(&o.Base, 12) + o.templates = property.NewPartList[element.Element]("Templates") + o.templates.Bind(&o.Base, 13) + o.scrollDirection = property.NewEnum[string]("ScrollDirection") + o.scrollDirection.Bind(&o.Base, 14) + o.numberOfColumns = property.NewPrimitive[int32]("NumberOfColumns", property.DecodeInt32) + o.numberOfColumns.Bind(&o.Base, 15) + o.pullDownAction = property.NewPart[element.Element]("PullDownAction") + o.pullDownAction.Bind(&o.Base, 16) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.dataSource, o.widget, o.widgets, o.pageSize, o.clickAction, o.editable, o.templates, o.scrollDirection, o.numberOfColumns, o.pullDownAction, }) + return o +} + +// NewListView creates a new ListView for user code. Marked dirty (bit 63 = new element). +func NewListView() *ListView { + o := initListView() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListViewDatabaseSource creates a ListViewDatabaseSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListViewDatabaseSource() *ListViewDatabaseSource { + o := &ListViewDatabaseSource{} + o.SetTypeName("Forms$ListViewDatabaseSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 4) + o.databaseConstraints = property.NewPartList[element.Element]("DatabaseConstraints") + o.databaseConstraints.Bind(&o.Base, 5) + o.search = property.NewPart[element.Element]("Search") + o.search.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, o.sortBar, o.databaseConstraints, o.search, }) + return o +} + +// NewListViewDatabaseSource creates a new ListViewDatabaseSource for user code. Marked dirty (bit 63 = new element). +func NewListViewDatabaseSource() *ListViewDatabaseSource { + o := initListViewDatabaseSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListViewSearch creates a ListViewSearch with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListViewSearch() *ListViewSearch { + o := &ListViewSearch{} + o.SetTypeName("Forms$ListViewSearch") + o.searchPaths = property.NewPrimitive[string]("SearchPaths", property.DecodeString) + o.searchPaths.Bind(&o.Base, 0) + o.searchRefs = property.NewPartList[element.Element]("SearchRefs") + o.searchRefs.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.searchPaths, o.searchRefs, }) + return o +} + +// NewListViewSearch creates a new ListViewSearch for user code. Marked dirty (bit 63 = new element). +func NewListViewSearch() *ListViewSearch { + o := initListViewSearch() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListViewTemplate creates a ListViewTemplate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListViewTemplate() *ListViewTemplate { + o := &ListViewTemplate{} + o.SetTypeName("Forms$ListViewTemplate") + o.specialization = property.NewByNameRef[element.Element]("Specialization", "DomainModels$Entity") + o.specialization.Bind(&o.Base, 0) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 1) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.specialization, o.widget, o.widgets, }) + return o +} + +// NewListViewTemplate creates a new ListViewTemplate for user code. Marked dirty (bit 63 = new element). +func NewListViewTemplate() *ListViewTemplate { + o := initListViewTemplate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListViewXPathSource creates a ListViewXPathSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListViewXPathSource() *ListViewXPathSource { + o := &ListViewXPathSource{} + o.SetTypeName("Forms$ListViewXPathSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 4) + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 5) + o.search = property.NewPart[element.Element]("Search") + o.search.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, o.sortBar, o.xPathConstraint, o.search, }) + return o +} + +// NewListViewXPathSource creates a new ListViewXPathSource for user code. Marked dirty (bit 63 = new element). +func NewListViewXPathSource() *ListViewXPathSource { + o := initListViewXPathSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initListenTargetSource creates a ListenTargetSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initListenTargetSource() *ListenTargetSource { + o := &ListenTargetSource{} + o.SetTypeName("Forms$ListenTargetSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.listenTarget = property.NewPrimitive[string]("ListenTarget", property.DecodeString) + o.listenTarget.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.forceFullObjects, o.listenTarget, }) + return o +} + +// NewListenTargetSource creates a new ListenTargetSource for user code. Marked dirty (bit 63 = new element). +func NewListenTargetSource() *ListenTargetSource { + o := initListenTargetSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLocalVariable creates a LocalVariable with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLocalVariable() *LocalVariable { + o := &LocalVariable{} + o.SetTypeName("Forms$LocalVariable") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.variableType = property.NewPart[element.Element]("VariableType") + o.variableType.Bind(&o.Base, 1) + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.variableType, o.defaultValue, }) + return o +} + +// NewLocalVariable creates a new LocalVariable for user code. Marked dirty (bit 63 = new element). +func NewLocalVariable() *LocalVariable { + o := initLocalVariable() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLoginButton creates a LoginButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLoginButton() *LoginButton { + o := &LoginButton{} + o.SetTypeName("Forms$LoginButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.validationMessageWidget = property.NewPrimitive[string]("ValidationMessageWidget", property.DecodeString) + o.validationMessageWidget.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, o.validationMessageWidget, }) + return o +} + +// NewLoginButton creates a new LoginButton for user code. Marked dirty (bit 63 = new element). +func NewLoginButton() *LoginButton { + o := initLoginButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLoginIdTextBox creates a LoginIdTextBox with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLoginIdTextBox() *LoginIdTextBox { + o := &LoginIdTextBox{} + o.SetTypeName("Forms$LoginIdTextBox") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 5) + o.labelWidth = property.NewPrimitive[int32]("LabelWidth", property.DecodeInt32) + o.labelWidth.Bind(&o.Base, 6) + o.placeholder = property.NewPart[element.Element]("Placeholder") + o.placeholder.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.label, o.labelWidth, o.placeholder, }) + return o +} + +// NewLoginIdTextBox creates a new LoginIdTextBox for user code. Marked dirty (bit 63 = new element). +func NewLoginIdTextBox() *LoginIdTextBox { + o := initLoginIdTextBox() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLogoutButton creates a LogoutButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLogoutButton() *LogoutButton { + o := &LogoutButton{} + o.SetTypeName("Forms$LogoutButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, }) + return o +} + +// NewLogoutButton creates a new LogoutButton for user code. Marked dirty (bit 63 = new element). +func NewLogoutButton() *LogoutButton { + o := initLogoutButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMasterDetail creates a MasterDetail with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMasterDetail() *MasterDetail { + o := &MasterDetail{} + o.SetTypeName("Forms$MasterDetail") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.master = property.NewPart[element.Element]("Master") + o.master.Bind(&o.Base, 5) + o.detail = property.NewPart[element.Element]("Detail") + o.detail.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.master, o.detail, }) + return o +} + +// NewMasterDetail creates a new MasterDetail for user code. Marked dirty (bit 63 = new element). +func NewMasterDetail() *MasterDetail { + o := initMasterDetail() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMasterDetailDetailRegion creates a MasterDetailDetailRegion with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMasterDetailDetailRegion() *MasterDetailDetailRegion { + o := &MasterDetailDetailRegion{} + o.SetTypeName("Forms$MasterDetailDetailRegion") + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.responsiveWeight = property.NewPrimitive[int32]("ResponsiveWeight", property.DecodeInt32) + o.responsiveWeight.Bind(&o.Base, 3) + o.tabletWeight = property.NewPrimitive[int32]("TabletWeight", property.DecodeInt32) + o.tabletWeight.Bind(&o.Base, 4) + o.title = property.NewPart[element.Element]("Title") + o.title.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.widget, o.class, o.style, o.responsiveWeight, o.tabletWeight, o.title, }) + return o +} + +// NewMasterDetailDetailRegion creates a new MasterDetailDetailRegion for user code. Marked dirty (bit 63 = new element). +func NewMasterDetailDetailRegion() *MasterDetailDetailRegion { + o := initMasterDetailDetailRegion() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMasterDetailMasterRegion creates a MasterDetailMasterRegion with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMasterDetailMasterRegion() *MasterDetailMasterRegion { + o := &MasterDetailMasterRegion{} + o.SetTypeName("Forms$MasterDetailMasterRegion") + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.responsiveWeight = property.NewPrimitive[int32]("ResponsiveWeight", property.DecodeInt32) + o.responsiveWeight.Bind(&o.Base, 3) + o.tabletWeight = property.NewPrimitive[int32]("TabletWeight", property.DecodeInt32) + o.tabletWeight.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.widget, o.class, o.style, o.responsiveWeight, o.tabletWeight, }) + return o +} + +// NewMasterDetailMasterRegion creates a new MasterDetailMasterRegion for user code. Marked dirty (bit 63 = new element). +func NewMasterDetailMasterRegion() *MasterDetailMasterRegion { + o := initMasterDetailMasterRegion() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMenuBar creates a MenuBar with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMenuBar() *MenuBar { + o := &MenuBar{} + o.SetTypeName("Forms$MenuBar") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.menuSource = property.NewPart[element.Element]("MenuSource") + o.menuSource.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.menuSource, }) + return o +} + +// NewMenuBar creates a new MenuBar for user code. Marked dirty (bit 63 = new element). +func NewMenuBar() *MenuBar { + o := initMenuBar() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMenuDocumentSource creates a MenuDocumentSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMenuDocumentSource() *MenuDocumentSource { + o := &MenuDocumentSource{} + o.SetTypeName("Forms$MenuDocumentSource") + o.menu = property.NewByNameRef[element.Element]("Menu", "Menus$MenuDocument") + o.menu.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.menu, }) + return o +} + +// NewMenuDocumentSource creates a new MenuDocumentSource for user code. Marked dirty (bit 63 = new element). +func NewMenuDocumentSource() *MenuDocumentSource { + o := initMenuDocumentSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowClientAction creates a MicroflowClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowClientAction() *MicroflowClientAction { + o := &MicroflowClientAction{} + o.SetTypeName("Forms$MicroflowAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.microflowSettings = property.NewPart[element.Element]("MicroflowSettings") + o.microflowSettings.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.microflowSettings, }) + return o +} + +// NewMicroflowClientAction creates a new MicroflowClientAction for user code. Marked dirty (bit 63 = new element). +func NewMicroflowClientAction() *MicroflowClientAction { + o := initMicroflowClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowParameterMapping creates a MicroflowParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowParameterMapping() *MicroflowParameterMapping { + o := &MicroflowParameterMapping{} + o.SetTypeName("Forms$MicroflowParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Microflows$MicroflowParameter") + o.parameter.Bind(&o.Base, 0) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 1) + o.variable = property.NewPart[element.Element]("Variable") + o.variable.Bind(&o.Base, 2) + o.widget = property.NewByNameRef[element.Element]("Widget", "Forms$EntityWidget") + o.widget.Bind(&o.Base, 3) + o.useAllPages = property.NewPrimitive[bool]("UseAllPages", property.DecodeBool) + o.useAllPages.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.parameter, o.expression, o.variable, o.widget, o.useAllPages, }) + return o +} + +// NewMicroflowParameterMapping creates a new MicroflowParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewMicroflowParameterMapping() *MicroflowParameterMapping { + o := initMicroflowParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowSettings creates a MicroflowSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowSettings() *MicroflowSettings { + o := &MicroflowSettings{} + o.SetTypeName("Forms$MicroflowSettings") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 1) + o.useAllPages = property.NewPrimitive[bool]("UseAllPages", property.DecodeBool) + o.useAllPages.Bind(&o.Base, 2) + o.progressBar = property.NewEnum[string]("ProgressBar") + o.progressBar.Bind(&o.Base, 3) + o.progressMessage = property.NewPart[element.Element]("ProgressMessage") + o.progressMessage.Bind(&o.Base, 4) + o.asynchronous = property.NewPrimitive[bool]("Asynchronous", property.DecodeBool) + o.asynchronous.Bind(&o.Base, 5) + o.formValidations = property.NewEnum[string]("FormValidations") + o.formValidations.Bind(&o.Base, 6) + o.confirmationInfo = property.NewPart[element.Element]("ConfirmationInfo") + o.confirmationInfo.Bind(&o.Base, 7) + o.outputMappings = property.NewPartList[element.Element]("OutputMappings") + o.outputMappings.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.microflow, o.parameterMappings, o.useAllPages, o.progressBar, o.progressMessage, o.asynchronous, o.formValidations, o.confirmationInfo, o.outputMappings, }) + return o +} + +// NewMicroflowSettings creates a new MicroflowSettings for user code. Marked dirty (bit 63 = new element). +func NewMicroflowSettings() *MicroflowSettings { + o := initMicroflowSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowSource creates a MicroflowSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowSource() *MicroflowSource { + o := &MicroflowSource{} + o.SetTypeName("Forms$MicroflowSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.microflowSettings = property.NewPart[element.Element]("MicroflowSettings") + o.microflowSettings.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.forceFullObjects, o.microflowSettings, }) + return o +} + +// NewMicroflowSource creates a new MicroflowSource for user code. Marked dirty (bit 63 = new element). +func NewMicroflowSource() *MicroflowSource { + o := initMicroflowSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNamedValue creates a NamedValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNamedValue() *NamedValue { + o := &NamedValue{} + o.SetTypeName("Forms$NamedValue") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.value, }) + return o +} + +// NewNamedValue creates a new NamedValue for user code. Marked dirty (bit 63 = new element). +func NewNamedValue() *NamedValue { + o := initNamedValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNanoflowParameterMapping creates a NanoflowParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNanoflowParameterMapping() *NanoflowParameterMapping { + o := &NanoflowParameterMapping{} + o.SetTypeName("Forms$NanoflowParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Microflows$NanoflowParameter") + o.parameter.Bind(&o.Base, 0) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 1) + o.variable = property.NewPart[element.Element]("Variable") + o.variable.Bind(&o.Base, 2) + o.widget = property.NewByNameRef[element.Element]("Widget", "Forms$EntityWidget") + o.widget.Bind(&o.Base, 3) + o.useAllPages = property.NewPrimitive[bool]("UseAllPages", property.DecodeBool) + o.useAllPages.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.parameter, o.expression, o.variable, o.widget, o.useAllPages, }) + return o +} + +// NewNanoflowParameterMapping creates a new NanoflowParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewNanoflowParameterMapping() *NanoflowParameterMapping { + o := initNanoflowParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNanoflowSource creates a NanoflowSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNanoflowSource() *NanoflowSource { + o := &NanoflowSource{} + o.SetTypeName("Forms$NanoflowSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.nanoflow = property.NewByNameRef[element.Element]("Nanoflow", "Microflows$Nanoflow") + o.nanoflow.Bind(&o.Base, 1) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.forceFullObjects, o.nanoflow, o.parameterMappings, }) + return o +} + +// NewNanoflowSource creates a new NanoflowSource for user code. Marked dirty (bit 63 = new element). +func NewNanoflowSource() *NanoflowSource { + o := initNanoflowSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNativeLayoutContent creates a NativeLayoutContent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNativeLayoutContent() *NativeLayoutContent { + o := &NativeLayoutContent{} + o.SetTypeName("Forms$NativeLayoutContent") + o.layoutType = property.NewEnum[string]("LayoutType") + o.layoutType.Bind(&o.Base, 0) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 1) + o.rightHeaderPlaceholder = property.NewPart[element.Element]("RightHeaderPlaceholder") + o.rightHeaderPlaceholder.Bind(&o.Base, 2) + o.showBottomBar = property.NewPrimitive[bool]("ShowBottomBar", property.DecodeBool) + o.showBottomBar.Bind(&o.Base, 3) + o.sidebar = property.NewPrimitive[bool]("Sidebar", property.DecodeBool) + o.sidebar.Bind(&o.Base, 4) + o.sidebarWidgets = property.NewPartList[element.Element]("SidebarWidgets") + o.sidebarWidgets.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.layoutType, o.widgets, o.rightHeaderPlaceholder, o.showBottomBar, o.sidebar, o.sidebarWidgets, }) + return o +} + +// NewNativeLayoutContent creates a new NativeLayoutContent for user code. Marked dirty (bit 63 = new element). +func NewNativeLayoutContent() *NativeLayoutContent { + o := initNativeLayoutContent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNavigationList creates a NavigationList with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNavigationList() *NavigationList { + o := &NavigationList{} + o.SetTypeName("Forms$NavigationList") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.items, }) + return o +} + +// NewNavigationList creates a new NavigationList for user code. Marked dirty (bit 63 = new element). +func NewNavigationList() *NavigationList { + o := initNavigationList() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNavigationListItem creates a NavigationListItem with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNavigationListItem() *NavigationListItem { + o := &NavigationListItem{} + o.SetTypeName("Forms$NavigationListItem") + o.action = property.NewPart[element.Element]("Action") + o.action.Bind(&o.Base, 0) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 1) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 2) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 3) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 4) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 5) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.action, o.widget, o.widgets, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, }) + return o +} + +// NewNavigationListItem creates a new NavigationListItem for user code. Marked dirty (bit 63 = new element). +func NewNavigationListItem() *NavigationListItem { + o := initNavigationListItem() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNavigationSource creates a NavigationSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNavigationSource() *NavigationSource { + o := &NavigationSource{} + o.SetTypeName("Forms$NavigationSource") + o.profileType = property.NewEnum[string]("ProfileType") + o.profileType.Bind(&o.Base, 0) + o.navigationProfile = property.NewByNameRef[element.Element]("NavigationProfile", "Navigation$NavigationProfile") + o.navigationProfile.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.profileType, o.navigationProfile, }) + return o +} + +// NewNavigationSource creates a new NavigationSource for user code. Marked dirty (bit 63 = new element). +func NewNavigationSource() *NavigationSource { + o := initNavigationSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNavigationTree creates a NavigationTree with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNavigationTree() *NavigationTree { + o := &NavigationTree{} + o.SetTypeName("Forms$NavigationTree") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.menuSource = property.NewPart[element.Element]("MenuSource") + o.menuSource.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.menuSource, }) + return o +} + +// NewNavigationTree creates a new NavigationTree for user code. Marked dirty (bit 63 = new element). +func NewNavigationTree() *NavigationTree { + o := initNavigationTree() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNewButton creates a NewButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNewButton() *NewButton { + o := &NewButton{} + o.SetTypeName("Forms$NewButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 12) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 13) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 14) + o.pageSettings = property.NewPart[element.Element]("PageSettings") + o.pageSettings.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, o.entity, o.entityPath, o.entityRef, o.pageSettings, }) + return o +} + +// NewNewButton creates a new NewButton for user code. Marked dirty (bit 63 = new element). +func NewNewButton() *NewButton { + o := initNewButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNoClientAction creates a NoClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNoClientAction() *NoClientAction { + o := &NoClientAction{} + o.SetTypeName("Forms$NoAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.disabledDuringExecution, }) + return o +} + +// NewNoClientAction creates a new NoClientAction for user code. Marked dirty (bit 63 = new element). +func NewNoClientAction() *NoClientAction { + o := initNoClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOfflineSchema creates a OfflineSchema with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOfflineSchema() *OfflineSchema { + o := &OfflineSchema{} + o.SetTypeName("Forms$OfflineSchema") + o.role = property.NewByNameRef[element.Element]("Role", "Security$UserRole") + o.role.Bind(&o.Base, 0) + o.tables = property.NewPrimitive[string]("Tables", property.DecodeString) + o.tables.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.role, o.tables, }) + return o +} + +// NewOfflineSchema creates a new OfflineSchema for user code. Marked dirty (bit 63 = new element). +func NewOfflineSchema() *OfflineSchema { + o := initOfflineSchema() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOfflineSchemaFetchInstruction creates a OfflineSchemaFetchInstruction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOfflineSchemaFetchInstruction() *OfflineSchemaFetchInstruction { + o := &OfflineSchemaFetchInstruction{} + o.SetTypeName("Forms$OfflineSchemaFetchInstruction") + o.tableName = property.NewPrimitive[string]("TableName", property.DecodeString) + o.tableName.Bind(&o.Base, 0) + o.xPath = property.NewPrimitive[string]("XPath", property.DecodeString) + o.xPath.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.tableName, o.xPath, }) + return o +} + +// NewOfflineSchemaFetchInstruction creates a new OfflineSchemaFetchInstruction for user code. Marked dirty (bit 63 = new element). +func NewOfflineSchemaFetchInstruction() *OfflineSchemaFetchInstruction { + o := initOfflineSchemaFetchInstruction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOnClickEnlarge creates a OnClickEnlarge with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOnClickEnlarge() *OnClickEnlarge { + o := &OnClickEnlarge{} + o.SetTypeName("Forms$OnClickEnlarge") + o.SetProperties([]element.Property{}) + return o +} + +// NewOnClickEnlarge creates a new OnClickEnlarge for user code. Marked dirty (bit 63 = new element). +func NewOnClickEnlarge() *OnClickEnlarge { + o := initOnClickEnlarge() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOnClickMicroflow creates a OnClickMicroflow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOnClickMicroflow() *OnClickMicroflow { + o := &OnClickMicroflow{} + o.SetTypeName("Forms$OnClickMicroflow") + o.microflowSettings = property.NewPart[element.Element]("MicroflowSettings") + o.microflowSettings.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflowSettings, }) + return o +} + +// NewOnClickMicroflow creates a new OnClickMicroflow for user code. Marked dirty (bit 63 = new element). +func NewOnClickMicroflow() *OnClickMicroflow { + o := initOnClickMicroflow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOnClickNothing creates a OnClickNothing with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOnClickNothing() *OnClickNothing { + o := &OnClickNothing{} + o.SetTypeName("Forms$OnClickNothing") + o.SetProperties([]element.Property{}) + return o +} + +// NewOnClickNothing creates a new OnClickNothing for user code. Marked dirty (bit 63 = new element). +func NewOnClickNothing() *OnClickNothing { + o := initOnClickNothing() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOpenLinkClientAction creates a OpenLinkClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOpenLinkClientAction() *OpenLinkClientAction { + o := &OpenLinkClientAction{} + o.SetTypeName("Forms$OpenLinkClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.linkType = property.NewEnum[string]("LinkType") + o.linkType.Bind(&o.Base, 1) + o.address = property.NewPart[element.Element]("Address") + o.address.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.linkType, o.address, }) + return o +} + +// NewOpenLinkClientAction creates a new OpenLinkClientAction for user code. Marked dirty (bit 63 = new element). +func NewOpenLinkClientAction() *OpenLinkClientAction { + o := initOpenLinkClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOpenUserTaskClientAction creates a OpenUserTaskClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOpenUserTaskClientAction() *OpenUserTaskClientAction { + o := &OpenUserTaskClientAction{} + o.SetTypeName("Forms$OpenUserTaskClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.assignOnOpen = property.NewPrimitive[bool]("AssignOnOpen", property.DecodeBool) + o.assignOnOpen.Bind(&o.Base, 1) + o.openWhenAssigned = property.NewPrimitive[bool]("OpenWhenAssigned", property.DecodeBool) + o.openWhenAssigned.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.assignOnOpen, o.openWhenAssigned, }) + return o +} + +// NewOpenUserTaskClientAction creates a new OpenUserTaskClientAction for user code. Marked dirty (bit 63 = new element). +func NewOpenUserTaskClientAction() *OpenUserTaskClientAction { + o := initOpenUserTaskClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOpenWorkflowClientAction creates a OpenWorkflowClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOpenWorkflowClientAction() *OpenWorkflowClientAction { + o := &OpenWorkflowClientAction{} + o.SetTypeName("Forms$OpenWorkflowClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.defaultPage = property.NewByNameRef[element.Element]("DefaultPage", "Forms$Page") + o.defaultPage.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.defaultPage, }) + return o +} + +// NewOpenWorkflowClientAction creates a new OpenWorkflowClientAction for user code. Marked dirty (bit 63 = new element). +func NewOpenWorkflowClientAction() *OpenWorkflowClientAction { + o := initOpenWorkflowClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOptionDesignPropertyValue creates a OptionDesignPropertyValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOptionDesignPropertyValue() *OptionDesignPropertyValue { + o := &OptionDesignPropertyValue{} + o.SetTypeName("Forms$OptionDesignPropertyValue") + o.option = property.NewPrimitive[string]("Option", property.DecodeString) + o.option.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.option, }) + return o +} + +// NewOptionDesignPropertyValue creates a new OptionDesignPropertyValue for user code. Marked dirty (bit 63 = new element). +func NewOptionDesignPropertyValue() *OptionDesignPropertyValue { + o := initOptionDesignPropertyValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOutputMapping creates a OutputMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOutputMapping() *OutputMapping { + o := &OutputMapping{} + o.SetTypeName("Forms$OutputMapping") + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 0) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 1) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 2) + o.sourceAttributeRef = property.NewPart[element.Element]("SourceAttributeRef") + o.sourceAttributeRef.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.sourceVariable, o.expression, o.attributeRef, o.sourceAttributeRef, }) + return o +} + +// NewOutputMapping creates a new OutputMapping for user code. Marked dirty (bit 63 = new element). +func NewOutputMapping() *OutputMapping { + o := initOutputMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOverviewPageTemplateType creates a OverviewPageTemplateType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOverviewPageTemplateType() *OverviewPageTemplateType { + o := &OverviewPageTemplateType{} + o.SetTypeName("Forms$OverviewPageTemplateType") + o.SetProperties([]element.Property{}) + return o +} + +// NewOverviewPageTemplateType creates a new OverviewPageTemplateType for user code. Marked dirty (bit 63 = new element). +func NewOverviewPageTemplateType() *OverviewPageTemplateType { + o := initOverviewPageTemplateType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPage creates a Page with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPage() *Page { + o := &Page{} + o.SetTypeName("Forms$Page") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.canvasWidth = property.NewPrimitive[int32]("CanvasWidth", property.DecodeInt32) + o.canvasWidth.Bind(&o.Base, 4) + o.canvasHeight = property.NewPrimitive[int32]("CanvasHeight", property.DecodeInt32) + o.canvasHeight.Bind(&o.Base, 5) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 6) + o.layoutCall = property.NewPart[element.Element]("LayoutCall") + o.layoutCall.Bind(&o.Base, 7) + o.title = property.NewPart[element.Element]("Title") + o.title.Bind(&o.Base, 8) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 9) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 10) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 11) + o.allowedRoles = property.NewByNameRefList[element.Element]("AllowedRoles", "Security$ModuleRole") + o.allowedRoles.Bind(&o.Base, 12) + o.popupCloseAction = property.NewPrimitive[string]("PopupCloseAction", property.DecodeString) + o.popupCloseAction.Bind(&o.Base, 13) + o.popupWidth = property.NewPrimitive[int32]("PopupWidth", property.DecodeInt32) + o.popupWidth.Bind(&o.Base, 14) + o.popupHeight = property.NewPrimitive[int32]("PopupHeight", property.DecodeInt32) + o.popupHeight.Bind(&o.Base, 15) + o.popupResizable = property.NewPrimitive[bool]("PopupResizable", property.DecodeBool) + o.popupResizable.Bind(&o.Base, 16) + o.markAsUsed = property.NewPrimitive[bool]("MarkAsUsed", property.DecodeBool) + o.markAsUsed.Bind(&o.Base, 17) + o.url = property.NewPrimitive[string]("Url", property.DecodeString) + o.url.Bind(&o.Base, 18) + o.autofocus = property.NewEnum[string]("Autofocus") + o.autofocus.Bind(&o.Base, 19) + o.variables = property.NewPartList[element.Element]("Variables") + o.variables.Bind(&o.Base, 20) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.canvasWidth, o.canvasHeight, o.parameters, o.layoutCall, o.title, o.class, o.style, o.appearance, o.allowedRoles, o.popupCloseAction, o.popupWidth, o.popupHeight, o.popupResizable, o.markAsUsed, o.url, o.autofocus, o.variables, }) + return o +} + +// NewPage creates a new Page for user code. Marked dirty (bit 63 = new element). +func NewPage() *Page { + o := initPage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPageClientAction creates a PageClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPageClientAction() *PageClientAction { + o := &PageClientAction{} + o.SetTypeName("Forms$FormAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.pageSettings = property.NewPart[element.Element]("FormSettings") + o.pageSettings.Bind(&o.Base, 1) + o.pagesForSpecializations = property.NewPartList[element.Element]("PagesForSpecializations") + o.pagesForSpecializations.Bind(&o.Base, 2) + o.numberOfPagesToClose = property.NewPrimitive[int32]("NumberOfPagesToClose", property.DecodeInt32) + o.numberOfPagesToClose.Bind(&o.Base, 3) + o.numberOfPagesToClose2 = property.NewPrimitive[string]("NumberOfPagesToClose2", property.DecodeString) + o.numberOfPagesToClose2.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.pageSettings, o.pagesForSpecializations, o.numberOfPagesToClose, o.numberOfPagesToClose2, }) + return o +} + +// NewPageClientAction creates a new PageClientAction for user code. Marked dirty (bit 63 = new element). +func NewPageClientAction() *PageClientAction { + o := initPageClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPageForSpecialization creates a PageForSpecialization with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPageForSpecialization() *PageForSpecialization { + o := &PageForSpecialization{} + o.SetTypeName("Forms$FormForSpecialization") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.pageSettings = property.NewPart[element.Element]("PageSettings") + o.pageSettings.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.entity, o.pageSettings, }) + return o +} + +// NewPageForSpecialization creates a new PageForSpecialization for user code. Marked dirty (bit 63 = new element). +func NewPageForSpecialization() *PageForSpecialization { + o := initPageForSpecialization() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPageParameter creates a PageParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPageParameter() *PageParameter { + o := &PageParameter{} + o.SetTypeName("Forms$PageParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 1) + o.isRequired = property.NewPrimitive[bool]("IsRequired", property.DecodeBool) + o.isRequired.Bind(&o.Base, 2) + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.name, o.parameterType, o.isRequired, o.defaultValue, }) + return o +} + +// NewPageParameter creates a new PageParameter for user code. Marked dirty (bit 63 = new element). +func NewPageParameter() *PageParameter { + o := initPageParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPageParameterMapping creates a PageParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPageParameterMapping() *PageParameterMapping { + o := &PageParameterMapping{} + o.SetTypeName("Forms$FormCallArgument") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Forms$PageParameter") + o.parameter.Bind(&o.Base, 0) + o.variable = property.NewPart[element.Element]("Variable") + o.variable.Bind(&o.Base, 1) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.parameter, o.variable, o.argument, }) + return o +} + +// NewPageParameterMapping creates a new PageParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewPageParameterMapping() *PageParameterMapping { + o := initPageParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPagePrimitiveParameterUrlSegment creates a PagePrimitiveParameterUrlSegment with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPagePrimitiveParameterUrlSegment() *PagePrimitiveParameterUrlSegment { + o := &PagePrimitiveParameterUrlSegment{} + o.SetTypeName("Forms$PagePrimitiveParameterUrlSegment") + o.pageParameter = property.NewByNameRef[element.Element]("PageParameter", "Forms$PageParameter") + o.pageParameter.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.pageParameter, }) + return o +} + +// NewPagePrimitiveParameterUrlSegment creates a new PagePrimitiveParameterUrlSegment for user code. Marked dirty (bit 63 = new element). +func NewPagePrimitiveParameterUrlSegment() *PagePrimitiveParameterUrlSegment { + o := initPagePrimitiveParameterUrlSegment() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPageSettings creates a PageSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPageSettings() *PageSettings { + o := &PageSettings{} + o.SetTypeName("Forms$FormSettings") + o.page = property.NewByNameRef[element.Element]("Form", "Forms$Page") + o.page.Bind(&o.Base, 0) + o.formTitle = property.NewPart[element.Element]("FormTitle") + o.formTitle.Bind(&o.Base, 1) + o.titleOverride = property.NewPart[element.Element]("TitleOverride") + o.titleOverride.Bind(&o.Base, 2) + o.location = property.NewEnum[string]("Location") + o.location.Bind(&o.Base, 3) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.page, o.formTitle, o.titleOverride, o.location, o.parameterMappings, }) + return o +} + +// NewPageSettings creates a new PageSettings for user code. Marked dirty (bit 63 = new element). +func NewPageSettings() *PageSettings { + o := initPageSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPageTemplate creates a PageTemplate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPageTemplate() *PageTemplate { + o := &PageTemplate{} + o.SetTypeName("Forms$PageTemplate") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.canvasWidth = property.NewPrimitive[int32]("CanvasWidth", property.DecodeInt32) + o.canvasWidth.Bind(&o.Base, 4) + o.canvasHeight = property.NewPrimitive[int32]("CanvasHeight", property.DecodeInt32) + o.canvasHeight.Bind(&o.Base, 5) + o.displayName = property.NewPrimitive[string]("DisplayName", property.DecodeString) + o.displayName.Bind(&o.Base, 6) + o.documentationUrl = property.NewPrimitive[string]("DocumentationUrl", property.DecodeString) + o.documentationUrl.Bind(&o.Base, 7) + o.templateCategory = property.NewPrimitive[string]("TemplateCategory", property.DecodeString) + o.templateCategory.Bind(&o.Base, 8) + o.templateCategoryWeight = property.NewPrimitive[int32]("TemplateCategoryWeight", property.DecodeInt32) + o.templateCategoryWeight.Bind(&o.Base, 9) + o.imageData = property.NewPrimitive[string]("ImageData", property.DecodeString) + o.imageData.Bind(&o.Base, 10) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 11) + o.layoutCall = property.NewPart[element.Element]("LayoutCall") + o.layoutCall.Bind(&o.Base, 12) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 13) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 14) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 15) + o.templateType = property.NewPart[element.Element]("TemplateType") + o.templateType.Bind(&o.Base, 16) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.canvasWidth, o.canvasHeight, o.displayName, o.documentationUrl, o.templateCategory, o.templateCategoryWeight, o.imageData, o.propType, o.layoutCall, o.class, o.style, o.appearance, o.templateType, }) + return o +} + +// NewPageTemplate creates a new PageTemplate for user code. Marked dirty (bit 63 = new element). +func NewPageTemplate() *PageTemplate { + o := initPageTemplate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPageVariable creates a PageVariable with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPageVariable() *PageVariable { + o := &PageVariable{} + o.SetTypeName("Forms$PageVariable") + o.widget = property.NewByNameRef[element.Element]("Widget", "Forms$Widget") + o.widget.Bind(&o.Base, 0) + o.pageParameter = property.NewByNameRef[element.Element]("PageParameter", "Forms$PageParameter") + o.pageParameter.Bind(&o.Base, 1) + o.snippetParameter = property.NewByNameRef[element.Element]("SnippetParameter", "Forms$SnippetParameter") + o.snippetParameter.Bind(&o.Base, 2) + o.localVariable = property.NewByNameRef[element.Element]("LocalVariable", "Forms$LocalVariable") + o.localVariable.Bind(&o.Base, 3) + o.useAllPages = property.NewPrimitive[bool]("UseAllPages", property.DecodeBool) + o.useAllPages.Bind(&o.Base, 4) + o.subKey = property.NewPrimitive[string]("SubKey", property.DecodeString) + o.subKey.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.widget, o.pageParameter, o.snippetParameter, o.localVariable, o.useAllPages, o.subKey, }) + return o +} + +// NewPageVariable creates a new PageVariable for user code. Marked dirty (bit 63 = new element). +func NewPageVariable() *PageVariable { + o := initPageVariable() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initParameterAttributeUrlSegment creates a ParameterAttributeUrlSegment with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initParameterAttributeUrlSegment() *ParameterAttributeUrlSegment { + o := &ParameterAttributeUrlSegment{} + o.SetTypeName("Forms$ParameterAttributeUrlSegment") + o.pageParameter = property.NewByNameRef[element.Element]("PageParameter", "Forms$PageParameter") + o.pageParameter.Bind(&o.Base, 0) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.pageParameter, o.attribute, }) + return o +} + +// NewParameterAttributeUrlSegment creates a new ParameterAttributeUrlSegment for user code. Marked dirty (bit 63 = new element). +func NewParameterAttributeUrlSegment() *ParameterAttributeUrlSegment { + o := initParameterAttributeUrlSegment() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initParameterIdUrlSegment creates a ParameterIdUrlSegment with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initParameterIdUrlSegment() *ParameterIdUrlSegment { + o := &ParameterIdUrlSegment{} + o.SetTypeName("Forms$ParameterIdUrlSegment") + o.pageParameter = property.NewByNameRef[element.Element]("PageParameter", "Forms$PageParameter") + o.pageParameter.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.pageParameter, }) + return o +} + +// NewParameterIdUrlSegment creates a new ParameterIdUrlSegment for user code. Marked dirty (bit 63 = new element). +func NewParameterIdUrlSegment() *ParameterIdUrlSegment { + o := initParameterIdUrlSegment() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPasswordTextBox creates a PasswordTextBox with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPasswordTextBox() *PasswordTextBox { + o := &PasswordTextBox{} + o.SetTypeName("Forms$PasswordTextBox") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 5) + o.labelWidth = property.NewPrimitive[int32]("LabelWidth", property.DecodeInt32) + o.labelWidth.Bind(&o.Base, 6) + o.placeholder = property.NewPart[element.Element]("Placeholder") + o.placeholder.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.label, o.labelWidth, o.placeholder, }) + return o +} + +// NewPasswordTextBox creates a new PasswordTextBox for user code. Marked dirty (bit 63 = new element). +func NewPasswordTextBox() *PasswordTextBox { + o := initPasswordTextBox() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPlaceholder creates a Placeholder with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPlaceholder() *Placeholder { + o := &Placeholder{} + o.SetTypeName("Forms$Placeholder") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, }) + return o +} + +// NewPlaceholder creates a new Placeholder for user code. Marked dirty (bit 63 = new element). +func NewPlaceholder() *Placeholder { + o := initPlaceholder() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRadioButtonGroup creates a RadioButtonGroup with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRadioButtonGroup() *RadioButtonGroup { + o := &RadioButtonGroup{} + o.SetTypeName("Forms$RadioButtonGroup") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 7) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 8) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 9) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 10) + o.screenReaderLabel = property.NewPart[element.Element]("ScreenReaderLabel") + o.screenReaderLabel.Bind(&o.Base, 11) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 12) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 13) + o.readOnlyStyle = property.NewEnum[string]("ReadOnlyStyle") + o.readOnlyStyle.Bind(&o.Base, 14) + o.required = property.NewPrimitive[bool]("Required", property.DecodeBool) + o.required.Bind(&o.Base, 15) + o.requiredMessage = property.NewPart[element.Element]("RequiredMessage") + o.requiredMessage.Bind(&o.Base, 16) + o.validation = property.NewPart[element.Element]("Validation") + o.validation.Bind(&o.Base, 17) + o.onChangeMicroflowSettings = property.NewPart[element.Element]("OnChangeMicroflowSettings") + o.onChangeMicroflowSettings.Bind(&o.Base, 18) + o.onEnterMicroflowSettings = property.NewPart[element.Element]("OnEnterMicroflowSettings") + o.onEnterMicroflowSettings.Bind(&o.Base, 19) + o.onLeaveMicroflowSettings = property.NewPart[element.Element]("OnLeaveMicroflowSettings") + o.onLeaveMicroflowSettings.Bind(&o.Base, 20) + o.onChangeAction = property.NewPart[element.Element]("OnChangeAction") + o.onChangeAction.Bind(&o.Base, 21) + o.onEnterAction = property.NewPart[element.Element]("OnEnterAction") + o.onEnterAction.Bind(&o.Base, 22) + o.onLeaveAction = property.NewPart[element.Element]("OnLeaveAction") + o.onLeaveAction.Bind(&o.Base, 23) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 24) + o.ariaRequired = property.NewPrimitive[bool]("AriaRequired", property.DecodeBool) + o.ariaRequired.Bind(&o.Base, 25) + o.renderHorizontal = property.NewPrimitive[bool]("RenderHorizontal", property.DecodeBool) + o.renderHorizontal.Bind(&o.Base, 26) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.conditionalEditabilitySettings, o.editable, o.label, o.labelTemplate, o.screenReaderLabel, o.attributePath, o.attributeRef, o.readOnlyStyle, o.required, o.requiredMessage, o.validation, o.onChangeMicroflowSettings, o.onEnterMicroflowSettings, o.onLeaveMicroflowSettings, o.onChangeAction, o.onEnterAction, o.onLeaveAction, o.sourceVariable, o.ariaRequired, o.renderHorizontal, }) + return o +} + +// NewRadioButtonGroup creates a new RadioButtonGroup for user code. Marked dirty (bit 63 = new element). +func NewRadioButtonGroup() *RadioButtonGroup { + o := initRadioButtonGroup() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRangeSearchField creates a RangeSearchField with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRangeSearchField() *RangeSearchField { + o := &RangeSearchField{} + o.SetTypeName("Forms$RangeSearchField") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.placeholder = property.NewPart[element.Element]("Placeholder") + o.placeholder.Bind(&o.Base, 2) + o.customDateFormat = property.NewPrimitive[string]("CustomDateFormat", property.DecodeString) + o.customDateFormat.Bind(&o.Base, 3) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 4) + o.defaultValue = property.NewPrimitive[string]("DefaultValue", property.DecodeString) + o.defaultValue.Bind(&o.Base, 5) + o.lowerBound = property.NewPrimitive[string]("LowerBound", property.DecodeString) + o.lowerBound.Bind(&o.Base, 6) + o.upperBound = property.NewPrimitive[string]("UpperBound", property.DecodeString) + o.upperBound.Bind(&o.Base, 7) + o.lowerBoundRef = property.NewPart[element.Element]("LowerBoundRef") + o.lowerBoundRef.Bind(&o.Base, 8) + o.upperBoundRef = property.NewPart[element.Element]("UpperBoundRef") + o.upperBoundRef.Bind(&o.Base, 9) + o.includeLower = property.NewPrimitive[bool]("IncludeLower", property.DecodeBool) + o.includeLower.Bind(&o.Base, 10) + o.includeUpper = property.NewPrimitive[bool]("IncludeUpper", property.DecodeBool) + o.includeUpper.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.caption, o.placeholder, o.customDateFormat, o.propType, o.defaultValue, o.lowerBound, o.upperBound, o.lowerBoundRef, o.upperBoundRef, o.includeLower, o.includeUpper, }) + return o +} + +// NewRangeSearchField creates a new RangeSearchField for user code. Marked dirty (bit 63 = new element). +func NewRangeSearchField() *RangeSearchField { + o := initRangeSearchField() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReferenceSelector creates a ReferenceSelector with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReferenceSelector() *ReferenceSelector { + o := &ReferenceSelector{} + o.SetTypeName("Forms$ReferenceSelector") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 7) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 8) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 9) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 10) + o.screenReaderLabel = property.NewPart[element.Element]("ScreenReaderLabel") + o.screenReaderLabel.Bind(&o.Base, 11) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 12) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 13) + o.readOnlyStyle = property.NewEnum[string]("ReadOnlyStyle") + o.readOnlyStyle.Bind(&o.Base, 14) + o.selectorSource = property.NewPart[element.Element]("SelectorSource") + o.selectorSource.Bind(&o.Base, 15) + o.selectPageSettings = property.NewPart[element.Element]("SelectPageSettings") + o.selectPageSettings.Bind(&o.Base, 16) + o.onChangeMicroflowSettings = property.NewPart[element.Element]("OnChangeMicroflowSettings") + o.onChangeMicroflowSettings.Bind(&o.Base, 17) + o.onChangeAction = property.NewPart[element.Element]("OnChangeAction") + o.onChangeAction.Bind(&o.Base, 18) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 19) + o.required = property.NewPrimitive[bool]("Required", property.DecodeBool) + o.required.Bind(&o.Base, 20) + o.requiredMessage = property.NewPart[element.Element]("RequiredMessage") + o.requiredMessage.Bind(&o.Base, 21) + o.validation = property.NewPart[element.Element]("Validation") + o.validation.Bind(&o.Base, 22) + o.renderMode = property.NewEnum[string]("RenderMode") + o.renderMode.Bind(&o.Base, 23) + o.gotoPageSettings = property.NewPart[element.Element]("GotoPageSettings") + o.gotoPageSettings.Bind(&o.Base, 24) + o.formattingInfo = property.NewPart[element.Element]("FormattingInfo") + o.formattingInfo.Bind(&o.Base, 25) + o.emptyOptionCaption = property.NewPart[element.Element]("EmptyOptionCaption") + o.emptyOptionCaption.Bind(&o.Base, 26) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 27) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.conditionalEditabilitySettings, o.editable, o.label, o.labelTemplate, o.screenReaderLabel, o.attributePath, o.attributeRef, o.readOnlyStyle, o.selectorSource, o.selectPageSettings, o.onChangeMicroflowSettings, o.onChangeAction, o.sourceVariable, o.required, o.requiredMessage, o.validation, o.renderMode, o.gotoPageSettings, o.formattingInfo, o.emptyOptionCaption, o.nativeAccessibilitySettings, }) + return o +} + +// NewReferenceSelector creates a new ReferenceSelector for user code. Marked dirty (bit 63 = new element). +func NewReferenceSelector() *ReferenceSelector { + o := initReferenceSelector() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReferenceSetSelector creates a ReferenceSetSelector with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReferenceSetSelector() *ReferenceSetSelector { + o := &ReferenceSetSelector{} + o.SetTypeName("Forms$ReferenceSetSelector") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.dataSource = property.NewPart[element.Element]("DataSource") + o.dataSource.Bind(&o.Base, 7) + o.isControlBarVisible = property.NewPrimitive[bool]("IsControlBarVisible", property.DecodeBool) + o.isControlBarVisible.Bind(&o.Base, 8) + o.isPagingEnabled = property.NewPrimitive[bool]("IsPagingEnabled", property.DecodeBool) + o.isPagingEnabled.Bind(&o.Base, 9) + o.showPagingBar = property.NewEnum[string]("ShowPagingBar") + o.showPagingBar.Bind(&o.Base, 10) + o.selectionMode = property.NewEnum[string]("SelectionMode") + o.selectionMode.Bind(&o.Base, 11) + o.selectFirst = property.NewPrimitive[bool]("SelectFirst", property.DecodeBool) + o.selectFirst.Bind(&o.Base, 12) + o.defaultButtonTrigger = property.NewEnum[string]("DefaultButtonTrigger") + o.defaultButtonTrigger.Bind(&o.Base, 13) + o.refreshTime = property.NewPrimitive[int32]("RefreshTime", property.DecodeInt32) + o.refreshTime.Bind(&o.Base, 14) + o.controlBar = property.NewPart[element.Element]("ControlBar") + o.controlBar.Bind(&o.Base, 15) + o.columns = property.NewPartList[element.Element]("Columns") + o.columns.Bind(&o.Base, 16) + o.numberOfRows = property.NewPrimitive[int32]("NumberOfRows", property.DecodeInt32) + o.numberOfRows.Bind(&o.Base, 17) + o.showEmptyRows = property.NewPrimitive[bool]("ShowEmptyRows", property.DecodeBool) + o.showEmptyRows.Bind(&o.Base, 18) + o.widthUnit = property.NewEnum[string]("WidthUnit") + o.widthUnit.Bind(&o.Base, 19) + o.tooltipPage = property.NewByNameRef[element.Element]("TooltipPage", "Forms$Page") + o.tooltipPage.Bind(&o.Base, 20) + o.onChangeMicroflowSettings = property.NewPart[element.Element]("OnChangeMicroflowSettings") + o.onChangeMicroflowSettings.Bind(&o.Base, 21) + o.onChangeAction = property.NewPart[element.Element]("OnChangeAction") + o.onChangeAction.Bind(&o.Base, 22) + o.constrainedBy = property.NewPrimitive[string]("ConstrainedBy", property.DecodeString) + o.constrainedBy.Bind(&o.Base, 23) + o.constrainedByRefs = property.NewPartList[element.Element]("ConstrainedByRefs") + o.constrainedByRefs.Bind(&o.Base, 24) + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 25) + o.removeAllFromContext = property.NewPrimitive[bool]("RemoveAllFromContext", property.DecodeBool) + o.removeAllFromContext.Bind(&o.Base, 26) + o.removeFromContextEntities = property.NewByNameRefList[element.Element]("RemoveFromContextEntities", "DomainModels$Entity") + o.removeFromContextEntities.Bind(&o.Base, 27) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.dataSource, o.isControlBarVisible, o.isPagingEnabled, o.showPagingBar, o.selectionMode, o.selectFirst, o.defaultButtonTrigger, o.refreshTime, o.controlBar, o.columns, o.numberOfRows, o.showEmptyRows, o.widthUnit, o.tooltipPage, o.onChangeMicroflowSettings, o.onChangeAction, o.constrainedBy, o.constrainedByRefs, o.xPathConstraint, o.removeAllFromContext, o.removeFromContextEntities, }) + return o +} + +// NewReferenceSetSelector creates a new ReferenceSetSelector for user code. Marked dirty (bit 63 = new element). +func NewReferenceSetSelector() *ReferenceSetSelector { + o := initReferenceSetSelector() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReferenceSetSource creates a ReferenceSetSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReferenceSetSource() *ReferenceSetSource { + o := &ReferenceSetSource{} + o.SetTypeName("Forms$ReferenceSetSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 4) + o.searchBar = property.NewPart[element.Element]("SearchBar") + o.searchBar.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, o.sortBar, o.searchBar, }) + return o +} + +// NewReferenceSetSource creates a new ReferenceSetSource for user code. Marked dirty (bit 63 = new element). +func NewReferenceSetSource() *ReferenceSetSource { + o := initReferenceSetSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRegularPageTemplateType creates a RegularPageTemplateType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRegularPageTemplateType() *RegularPageTemplateType { + o := &RegularPageTemplateType{} + o.SetTypeName("Forms$RegularPageTemplateType") + o.SetProperties([]element.Property{}) + return o +} + +// NewRegularPageTemplateType creates a new RegularPageTemplateType for user code. Marked dirty (bit 63 = new element). +func NewRegularPageTemplateType() *RegularPageTemplateType { + o := initRegularPageTemplateType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRetrievalQuery creates a RetrievalQuery with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRetrievalQuery() *RetrievalQuery { + o := &RetrievalQuery{} + o.SetTypeName("Forms$RetrievalQuery") + o.queryId = property.NewPrimitive[string]("QueryId", property.DecodeString) + o.queryId.Bind(&o.Base, 0) + o.allowedUserRoles = property.NewByNameRefList[element.Element]("AllowedUserRoles", "Security$UserRole") + o.allowedUserRoles.Bind(&o.Base, 1) + o.allowedUserRoleSets = property.NewPartList[element.Element]("AllowedUserRoleSets") + o.allowedUserRoleSets.Bind(&o.Base, 2) + o.xPath = property.NewPrimitive[string]("XPath", property.DecodeString) + o.xPath.Bind(&o.Base, 3) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 4) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 5) + o.pageName = property.NewPrimitive[string]("PageName", property.DecodeString) + o.pageName.Bind(&o.Base, 6) + o.widgetName = property.NewPrimitive[string]("WidgetName", property.DecodeString) + o.widgetName.Bind(&o.Base, 7) + o.usedAssociations = property.NewPrimitive[string]("UsedAssociations", property.DecodeString) + o.usedAssociations.Bind(&o.Base, 8) + o.usedAttributes = property.NewPrimitive[string]("UsedAttributes", property.DecodeString) + o.usedAttributes.Bind(&o.Base, 9) + o.schemaId = property.NewPrimitive[string]("SchemaId", property.DecodeString) + o.schemaId.Bind(&o.Base, 10) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.queryId, o.allowedUserRoles, o.allowedUserRoleSets, o.xPath, o.microflow, o.entityPath, o.pageName, o.widgetName, o.usedAssociations, o.usedAttributes, o.schemaId, o.parameters, }) + return o +} + +// NewRetrievalQuery creates a new RetrievalQuery for user code. Marked dirty (bit 63 = new element). +func NewRetrievalQuery() *RetrievalQuery { + o := initRetrievalQuery() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRetrievalQueryParameter creates a RetrievalQueryParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRetrievalQueryParameter() *RetrievalQueryParameter { + o := &RetrievalQueryParameter{} + o.SetTypeName("Forms$RetrievalQueryParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 1) + o.types = property.NewPrimitive[string]("Types", property.DecodeString) + o.types.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.propType, o.types, }) + return o +} + +// NewRetrievalQueryParameter creates a new RetrievalQueryParameter for user code. Marked dirty (bit 63 = new element). +func NewRetrievalQueryParameter() *RetrievalQueryParameter { + o := initRetrievalQueryParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRetrievalSchema creates a RetrievalSchema with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRetrievalSchema() *RetrievalSchema { + o := &RetrievalSchema{} + o.SetTypeName("Forms$RetrievalSchema") + o.usedAttributes = property.NewPrimitive[string]("UsedAttributes", property.DecodeString) + o.usedAttributes.Bind(&o.Base, 0) + o.usedAssociations = property.NewPrimitive[string]("UsedAssociations", property.DecodeString) + o.usedAssociations.Bind(&o.Base, 1) + o.widgetName = property.NewPrimitive[string]("WidgetName", property.DecodeString) + o.widgetName.Bind(&o.Base, 2) + o.entity = property.NewPrimitive[string]("Entity", property.DecodeString) + o.entity.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.usedAttributes, o.usedAssociations, o.widgetName, o.entity, }) + return o +} + +// NewRetrievalSchema creates a new RetrievalSchema for user code. Marked dirty (bit 63 = new element). +func NewRetrievalSchema() *RetrievalSchema { + o := initRetrievalSchema() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRuntimeOperation creates a RuntimeOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRuntimeOperation() *RuntimeOperation { + o := &RuntimeOperation{} + o.SetTypeName("Forms$RuntimeOperation") + o.operationId = property.NewPrimitive[string]("OperationId", property.DecodeString) + o.operationId.Bind(&o.Base, 0) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 1) + o.constants = property.NewPartList[element.Element]("Constants") + o.constants.Bind(&o.Base, 2) + o.operationType = property.NewPrimitive[string]("OperationType", property.DecodeString) + o.operationType.Bind(&o.Base, 3) + o.operationName = property.NewPrimitive[string]("OperationName", property.DecodeString) + o.operationName.Bind(&o.Base, 4) + o.allowedUserRoles = property.NewByNameRefList[element.Element]("AllowedUserRoles", "Security$UserRole") + o.allowedUserRoles.Bind(&o.Base, 5) + o.allowedUserRoleSets = property.NewPartList[element.Element]("AllowedUserRoleSets") + o.allowedUserRoleSets.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.operationId, o.parameters, o.constants, o.operationType, o.operationName, o.allowedUserRoles, o.allowedUserRoleSets, }) + return o +} + +// NewRuntimeOperation creates a new RuntimeOperation for user code. Marked dirty (bit 63 = new element). +func NewRuntimeOperation() *RuntimeOperation { + o := initRuntimeOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSaveButton creates a SaveButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSaveButton() *SaveButton { + o := &SaveButton{} + o.SetTypeName("Forms$SaveButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.syncAutomatically = property.NewPrimitive[bool]("SyncAutomatically", property.DecodeBool) + o.syncAutomatically.Bind(&o.Base, 12) + o.closePage = property.NewPrimitive[bool]("ClosePage", property.DecodeBool) + o.closePage.Bind(&o.Base, 13) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, o.syncAutomatically, o.closePage, }) + return o +} + +// NewSaveButton creates a new SaveButton for user code. Marked dirty (bit 63 = new element). +func NewSaveButton() *SaveButton { + o := initSaveButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSaveChangesClientAction creates a SaveChangesClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSaveChangesClientAction() *SaveChangesClientAction { + o := &SaveChangesClientAction{} + o.SetTypeName("Forms$SaveChangesClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.syncAutomatically = property.NewPrimitive[bool]("SyncAutomatically", property.DecodeBool) + o.syncAutomatically.Bind(&o.Base, 1) + o.closePage = property.NewPrimitive[bool]("ClosePage", property.DecodeBool) + o.closePage.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.syncAutomatically, o.closePage, }) + return o +} + +// NewSaveChangesClientAction creates a new SaveChangesClientAction for user code. Marked dirty (bit 63 = new element). +func NewSaveChangesClientAction() *SaveChangesClientAction { + o := initSaveChangesClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initScrollContainer creates a ScrollContainer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initScrollContainer() *ScrollContainer { + o := &ScrollContainer{} + o.SetTypeName("Forms$ScrollContainer") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.center = property.NewPart[element.Element]("Center") + o.center.Bind(&o.Base, 5) + o.left = property.NewPart[element.Element]("Left") + o.left.Bind(&o.Base, 6) + o.right = property.NewPart[element.Element]("Right") + o.right.Bind(&o.Base, 7) + o.top = property.NewPart[element.Element]("Top") + o.top.Bind(&o.Base, 8) + o.bottom = property.NewPart[element.Element]("Bottom") + o.bottom.Bind(&o.Base, 9) + o.layoutMode = property.NewEnum[string]("LayoutMode") + o.layoutMode.Bind(&o.Base, 10) + o.widthMode = property.NewEnum[string]("WidthMode") + o.widthMode.Bind(&o.Base, 11) + o.width = property.NewPrimitive[int32]("Width", property.DecodeInt32) + o.width.Bind(&o.Base, 12) + o.alignment = property.NewEnum[string]("Alignment") + o.alignment.Bind(&o.Base, 13) + o.scrollBehavior = property.NewEnum[string]("ScrollBehavior") + o.scrollBehavior.Bind(&o.Base, 14) + o.nativeHideScrollbars = property.NewPrimitive[bool]("NativeHideScrollbars", property.DecodeBool) + o.nativeHideScrollbars.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.center, o.left, o.right, o.top, o.bottom, o.layoutMode, o.widthMode, o.width, o.alignment, o.scrollBehavior, o.nativeHideScrollbars, }) + return o +} + +// NewScrollContainer creates a new ScrollContainer for user code. Marked dirty (bit 63 = new element). +func NewScrollContainer() *ScrollContainer { + o := initScrollContainer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initScrollContainerRegion creates a ScrollContainerRegion with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initScrollContainerRegion() *ScrollContainerRegion { + o := &ScrollContainerRegion{} + o.SetTypeName("Forms$ScrollContainerRegion") + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 0) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 1) + o.sizeMode = property.NewEnum[string]("SizeMode") + o.sizeMode.Bind(&o.Base, 2) + o.size = property.NewPrimitive[int32]("Size", property.DecodeInt32) + o.size.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.toggleMode = property.NewEnum[string]("ToggleMode") + o.toggleMode.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.widget, o.widgets, o.sizeMode, o.size, o.class, o.style, o.appearance, o.toggleMode, }) + return o +} + +// NewScrollContainerRegion creates a new ScrollContainerRegion for user code. Marked dirty (bit 63 = new element). +func NewScrollContainerRegion() *ScrollContainerRegion { + o := initScrollContainerRegion() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSearchBar creates a SearchBar with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSearchBar() *SearchBar { + o := &SearchBar{} + o.SetTypeName("Forms$SearchBar") + o.items = property.NewPartList[element.Element]("Items") + o.items.Bind(&o.Base, 0) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 1) + o.waitForSearch = property.NewPrimitive[bool]("WaitForSearch", property.DecodeBool) + o.waitForSearch.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.items, o.propType, o.waitForSearch, }) + return o +} + +// NewSearchBar creates a new SearchBar for user code. Marked dirty (bit 63 = new element). +func NewSearchBar() *SearchBar { + o := initSearchBar() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSelectButton creates a SelectButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSelectButton() *SelectButton { + o := &SelectButton{} + o.SetTypeName("Forms$SelectButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 2) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 3) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 4) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 5) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 6) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 7) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.caption, o.tooltip, o.icon, o.class, o.style, o.appearance, o.conditionalVisibilitySettings, o.buttonStyle, }) + return o +} + +// NewSelectButton creates a new SelectButton for user code. Marked dirty (bit 63 = new element). +func NewSelectButton() *SelectButton { + o := initSelectButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSelectPageTemplateType creates a SelectPageTemplateType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSelectPageTemplateType() *SelectPageTemplateType { + o := &SelectPageTemplateType{} + o.SetTypeName("Forms$SelectPageTemplateType") + o.SetProperties([]element.Property{}) + return o +} + +// NewSelectPageTemplateType creates a new SelectPageTemplateType for user code. Marked dirty (bit 63 = new element). +func NewSelectPageTemplateType() *SelectPageTemplateType { + o := initSelectPageTemplateType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSelectorDatabaseSource creates a SelectorDatabaseSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSelectorDatabaseSource() *SelectorDatabaseSource { + o := &SelectorDatabaseSource{} + o.SetTypeName("Forms$SelectorDatabaseSource") + o.databaseConstraints = property.NewPartList[element.Element]("DatabaseConstraints") + o.databaseConstraints.Bind(&o.Base, 0) + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.databaseConstraints, o.sortBar, }) + return o +} + +// NewSelectorDatabaseSource creates a new SelectorDatabaseSource for user code. Marked dirty (bit 63 = new element). +func NewSelectorDatabaseSource() *SelectorDatabaseSource { + o := initSelectorDatabaseSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSelectorMicroflowSource creates a SelectorMicroflowSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSelectorMicroflowSource() *SelectorMicroflowSource { + o := &SelectorMicroflowSource{} + o.SetTypeName("Forms$SelectorMicroflowSource") + o.dataSourceMicroflowSettings = property.NewPart[element.Element]("DataSourceMicroflowSettings") + o.dataSourceMicroflowSettings.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.dataSourceMicroflowSettings, }) + return o +} + +// NewSelectorMicroflowSource creates a new SelectorMicroflowSource for user code. Marked dirty (bit 63 = new element). +func NewSelectorMicroflowSource() *SelectorMicroflowSource { + o := initSelectorMicroflowSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSelectorXPathSource creates a SelectorXPathSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSelectorXPathSource() *SelectorXPathSource { + o := &SelectorXPathSource{} + o.SetTypeName("Forms$SelectorXPathSource") + o.sortBar = property.NewPart[element.Element]("SortBar") + o.sortBar.Bind(&o.Base, 0) + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 1) + o.constrainedBy = property.NewPrimitive[string]("ConstrainedBy", property.DecodeString) + o.constrainedBy.Bind(&o.Base, 2) + o.constrainedByRefs = property.NewPartList[element.Element]("ConstrainedByRefs") + o.constrainedByRefs.Bind(&o.Base, 3) + o.applyContext = property.NewPrimitive[bool]("ApplyContext", property.DecodeBool) + o.applyContext.Bind(&o.Base, 4) + o.removeAllFromContext = property.NewPrimitive[bool]("RemoveAllFromContext", property.DecodeBool) + o.removeAllFromContext.Bind(&o.Base, 5) + o.removeFromContextEntities = property.NewByNameRefList[element.Element]("RemoveFromContextEntities", "DomainModels$Entity") + o.removeFromContextEntities.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.sortBar, o.xPathConstraint, o.constrainedBy, o.constrainedByRefs, o.applyContext, o.removeAllFromContext, o.removeFromContextEntities, }) + return o +} + +// NewSelectorXPathSource creates a new SelectorXPathSource for user code. Marked dirty (bit 63 = new element). +func NewSelectorXPathSource() *SelectorXPathSource { + o := initSelectorXPathSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSetTaskOutcomeClientAction creates a SetTaskOutcomeClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSetTaskOutcomeClientAction() *SetTaskOutcomeClientAction { + o := &SetTaskOutcomeClientAction{} + o.SetTypeName("Forms$SetTaskOutcomeClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.outcome = property.NewByNameRef[element.Element]("Outcome", "Workflows$UserTaskOutcome") + o.outcome.Bind(&o.Base, 1) + o.outcomeValue = property.NewPrimitive[string]("OutcomeValue", property.DecodeString) + o.outcomeValue.Bind(&o.Base, 2) + o.closePage = property.NewPrimitive[bool]("ClosePage", property.DecodeBool) + o.closePage.Bind(&o.Base, 3) + o.commit = property.NewPrimitive[bool]("Commit", property.DecodeBool) + o.commit.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.disabledDuringExecution, o.outcome, o.outcomeValue, o.closePage, o.commit, }) + return o +} + +// NewSetTaskOutcomeClientAction creates a new SetTaskOutcomeClientAction for user code. Marked dirty (bit 63 = new element). +func NewSetTaskOutcomeClientAction() *SetTaskOutcomeClientAction { + o := initSetTaskOutcomeClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSidebarToggleButton creates a SidebarToggleButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSidebarToggleButton() *SidebarToggleButton { + o := &SidebarToggleButton{} + o.SetTypeName("Forms$SidebarToggleButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.region = property.NewEnum[string]("Region") + o.region.Bind(&o.Base, 12) + o.mode = property.NewEnum[string]("Mode") + o.mode.Bind(&o.Base, 13) + o.initiallyOpen = property.NewPrimitive[bool]("InitiallyOpen", property.DecodeBool) + o.initiallyOpen.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, o.region, o.mode, o.initiallyOpen, }) + return o +} + +// NewSidebarToggleButton creates a new SidebarToggleButton for user code. Marked dirty (bit 63 = new element). +func NewSidebarToggleButton() *SidebarToggleButton { + o := initSidebarToggleButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSignOutClientAction creates a SignOutClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSignOutClientAction() *SignOutClientAction { + o := &SignOutClientAction{} + o.SetTypeName("Forms$SignOutClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.disabledDuringExecution, }) + return o +} + +// NewSignOutClientAction creates a new SignOutClientAction for user code. Marked dirty (bit 63 = new element). +func NewSignOutClientAction() *SignOutClientAction { + o := initSignOutClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSimpleMenuBar creates a SimpleMenuBar with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSimpleMenuBar() *SimpleMenuBar { + o := &SimpleMenuBar{} + o.SetTypeName("Forms$SimpleMenuBar") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.menuSource = property.NewPart[element.Element]("MenuSource") + o.menuSource.Bind(&o.Base, 5) + o.orientation = property.NewEnum[string]("Orientation") + o.orientation.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.menuSource, o.orientation, }) + return o +} + +// NewSimpleMenuBar creates a new SimpleMenuBar for user code. Marked dirty (bit 63 = new element). +func NewSimpleMenuBar() *SimpleMenuBar { + o := initSimpleMenuBar() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSnippet creates a Snippet with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSnippet() *Snippet { + o := &Snippet{} + o.SetTypeName("Forms$Snippet") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.canvasWidth = property.NewPrimitive[int32]("CanvasWidth", property.DecodeInt32) + o.canvasWidth.Bind(&o.Base, 4) + o.canvasHeight = property.NewPrimitive[int32]("CanvasHeight", property.DecodeInt32) + o.canvasHeight.Bind(&o.Base, 5) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 6) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 7) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 8) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 9) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 10) + o.variables = property.NewPartList[element.Element]("Variables") + o.variables.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.canvasWidth, o.canvasHeight, o.entity, o.widget, o.widgets, o.propType, o.parameters, o.variables, }) + return o +} + +// NewSnippet creates a new Snippet for user code. Marked dirty (bit 63 = new element). +func NewSnippet() *Snippet { + o := initSnippet() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSnippetCall creates a SnippetCall with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSnippetCall() *SnippetCall { + o := &SnippetCall{} + o.SetTypeName("Forms$SnippetCall") + o.snippet = property.NewByNameRef[element.Element]("Snippet", "Forms$Snippet") + o.snippet.Bind(&o.Base, 0) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.snippet, o.parameterMappings, }) + return o +} + +// NewSnippetCall creates a new SnippetCall for user code. Marked dirty (bit 63 = new element). +func NewSnippetCall() *SnippetCall { + o := initSnippetCall() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSnippetCallWidget creates a SnippetCallWidget with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSnippetCallWidget() *SnippetCallWidget { + o := &SnippetCallWidget{} + o.SetTypeName("Forms$SnippetCallWidget") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.snippetCall = property.NewPart[element.Element]("SnippetCall") + o.snippetCall.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.snippetCall, }) + return o +} + +// NewSnippetCallWidget creates a new SnippetCallWidget for user code. Marked dirty (bit 63 = new element). +func NewSnippetCallWidget() *SnippetCallWidget { + o := initSnippetCallWidget() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSnippetParameter creates a SnippetParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSnippetParameter() *SnippetParameter { + o := &SnippetParameter{} + o.SetTypeName("Forms$SnippetParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.parameterType, }) + return o +} + +// NewSnippetParameter creates a new SnippetParameter for user code. Marked dirty (bit 63 = new element). +func NewSnippetParameter() *SnippetParameter { + o := initSnippetParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSnippetParameterMapping creates a SnippetParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSnippetParameterMapping() *SnippetParameterMapping { + o := &SnippetParameterMapping{} + o.SetTypeName("Forms$SnippetParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Forms$SnippetParameter") + o.parameter.Bind(&o.Base, 0) + o.variable = property.NewPart[element.Element]("Variable") + o.variable.Bind(&o.Base, 1) + o.argument = property.NewPrimitive[string]("Argument", property.DecodeString) + o.argument.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.parameter, o.variable, o.argument, }) + return o +} + +// NewSnippetParameterMapping creates a new SnippetParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewSnippetParameterMapping() *SnippetParameterMapping { + o := initSnippetParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStaticImageViewer creates a StaticImageViewer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStaticImageViewer() *StaticImageViewer { + o := &StaticImageViewer{} + o.SetTypeName("Forms$StaticImageViewer") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.image = property.NewByNameRef[element.Element]("Image", "Images$Image") + o.image.Bind(&o.Base, 7) + o.widthUnit = property.NewEnum[string]("WidthUnit") + o.widthUnit.Bind(&o.Base, 8) + o.heightUnit = property.NewEnum[string]("HeightUnit") + o.heightUnit.Bind(&o.Base, 9) + o.width = property.NewPrimitive[int32]("Width", property.DecodeInt32) + o.width.Bind(&o.Base, 10) + o.height = property.NewPrimitive[int32]("Height", property.DecodeInt32) + o.height.Bind(&o.Base, 11) + o.clickAction = property.NewPart[element.Element]("ClickAction") + o.clickAction.Bind(&o.Base, 12) + o.responsive = property.NewPrimitive[bool]("Responsive", property.DecodeBool) + o.responsive.Bind(&o.Base, 13) + o.alternativeText = property.NewPart[element.Element]("AlternativeText") + o.alternativeText.Bind(&o.Base, 14) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.image, o.widthUnit, o.heightUnit, o.width, o.height, o.clickAction, o.responsive, o.alternativeText, o.nativeAccessibilitySettings, }) + return o +} + +// NewStaticImageViewer creates a new StaticImageViewer for user code. Marked dirty (bit 63 = new element). +func NewStaticImageViewer() *StaticImageViewer { + o := initStaticImageViewer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStaticOrDynamicString creates a StaticOrDynamicString with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStaticOrDynamicString() *StaticOrDynamicString { + o := &StaticOrDynamicString{} + o.SetTypeName("Forms$StaticOrDynamicString") + o.isDynamic = property.NewPrimitive[bool]("IsDynamic", property.DecodeBool) + o.isDynamic.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.attribute = property.NewPrimitive[string]("Attribute", property.DecodeString) + o.attribute.Bind(&o.Base, 2) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.isDynamic, o.value, o.attribute, o.attributeRef, }) + return o +} + +// NewStaticOrDynamicString creates a new StaticOrDynamicString for user code. Marked dirty (bit 63 = new element). +func NewStaticOrDynamicString() *StaticOrDynamicString { + o := initStaticOrDynamicString() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStaticUrlSegment creates a StaticUrlSegment with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStaticUrlSegment() *StaticUrlSegment { + o := &StaticUrlSegment{} + o.SetTypeName("Forms$StaticUrlSegment") + o.segment = property.NewPrimitive[string]("Segment", property.DecodeString) + o.segment.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.segment, }) + return o +} + +// NewStaticUrlSegment creates a new StaticUrlSegment for user code. Marked dirty (bit 63 = new element). +func NewStaticUrlSegment() *StaticUrlSegment { + o := initStaticUrlSegment() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSyncButton creates a SyncButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSyncButton() *SyncButton { + o := &SyncButton{} + o.SetTypeName("Forms$SyncButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 7) + o.tooltip = property.NewPart[element.Element]("Tooltip") + o.tooltip.Bind(&o.Base, 8) + o.icon = property.NewPart[element.Element]("Icon") + o.icon.Bind(&o.Base, 9) + o.renderType = property.NewEnum[string]("RenderType") + o.renderType.Bind(&o.Base, 10) + o.buttonStyle = property.NewEnum[string]("ButtonStyle") + o.buttonStyle.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.caption, o.tooltip, o.icon, o.renderType, o.buttonStyle, }) + return o +} + +// NewSyncButton creates a new SyncButton for user code. Marked dirty (bit 63 = new element). +func NewSyncButton() *SyncButton { + o := initSyncButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSyncClientAction creates a SyncClientAction with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSyncClientAction() *SyncClientAction { + o := &SyncClientAction{} + o.SetTypeName("Forms$SyncClientAction") + o.disabledDuringExecution = property.NewPrimitive[bool]("DisabledDuringExecution", property.DecodeBool) + o.disabledDuringExecution.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.disabledDuringExecution, }) + return o +} + +// NewSyncClientAction creates a new SyncClientAction for user code. Marked dirty (bit 63 = new element). +func NewSyncClientAction() *SyncClientAction { + o := initSyncClientAction() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTabContainer creates a TabContainer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTabContainer() *TabContainer { + o := &TabContainer{} + o.SetTypeName("Forms$TabControl") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.tabPages = property.NewPartList[element.Element]("TabPages") + o.tabPages.Bind(&o.Base, 7) + o.defaultPage = property.NewByIdRef[element.Element]("DefaultPage") + o.defaultPage.Bind(&o.Base, 8) + o.activePageAttributeRef = property.NewPart[element.Element]("ActivePageAttributeRef") + o.activePageAttributeRef.Bind(&o.Base, 9) + o.activePageSourceVariable = property.NewPart[element.Element]("ActivePageSourceVariable") + o.activePageSourceVariable.Bind(&o.Base, 10) + o.activePageOnChangeAction = property.NewPart[element.Element]("ActivePageOnChangeAction") + o.activePageOnChangeAction.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.tabPages, o.defaultPage, o.activePageAttributeRef, o.activePageSourceVariable, o.activePageOnChangeAction, }) + return o +} + +// NewTabContainer creates a new TabContainer for user code. Marked dirty (bit 63 = new element). +func NewTabContainer() *TabContainer { + o := initTabContainer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTabPage creates a TabPage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTabPage() *TabPage { + o := &TabPage{} + o.SetTypeName("Forms$TabPage") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 1) + o.refreshOnShow = property.NewPrimitive[bool]("RefreshOnShow", property.DecodeBool) + o.refreshOnShow.Bind(&o.Base, 2) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 3) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 4) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 5) + o.badge = property.NewPart[element.Element]("Badge") + o.badge.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.caption, o.refreshOnShow, o.conditionalVisibilitySettings, o.widget, o.widgets, o.badge, }) + return o +} + +// NewTabPage creates a new TabPage for user code. Marked dirty (bit 63 = new element). +func NewTabPage() *TabPage { + o := initTabPage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTable creates a Table with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTable() *Table { + o := &Table{} + o.SetTypeName("Forms$Table") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.cells = property.NewPartList[element.Element]("Cells") + o.cells.Bind(&o.Base, 7) + o.columns = property.NewPartList[element.Element]("Columns") + o.columns.Bind(&o.Base, 8) + o.widthUnit = property.NewEnum[string]("WidthUnit") + o.widthUnit.Bind(&o.Base, 9) + o.rows = property.NewPartList[element.Element]("Rows") + o.rows.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.cells, o.columns, o.widthUnit, o.rows, }) + return o +} + +// NewTable creates a new Table for user code. Marked dirty (bit 63 = new element). +func NewTable() *Table { + o := initTable() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTableCell creates a TableCell with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTableCell() *TableCell { + o := &TableCell{} + o.SetTypeName("Forms$TableCell") + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 0) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 1) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 2) + o.isHeader = property.NewPrimitive[bool]("IsHeader", property.DecodeBool) + o.isHeader.Bind(&o.Base, 3) + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 4) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 5) + o.leftColumnIndex = property.NewPrimitive[int32]("LeftColumnIndex", property.DecodeInt32) + o.leftColumnIndex.Bind(&o.Base, 6) + o.topRowIndex = property.NewPrimitive[int32]("TopRowIndex", property.DecodeInt32) + o.topRowIndex.Bind(&o.Base, 7) + o.width = property.NewPrimitive[int32]("Width", property.DecodeInt32) + o.width.Bind(&o.Base, 8) + o.height = property.NewPrimitive[int32]("Height", property.DecodeInt32) + o.height.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.class, o.style, o.appearance, o.isHeader, o.widget, o.widgets, o.leftColumnIndex, o.topRowIndex, o.width, o.height, }) + return o +} + +// NewTableCell creates a new TableCell for user code. Marked dirty (bit 63 = new element). +func NewTableCell() *TableCell { + o := initTableCell() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTableColumn creates a TableColumn with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTableColumn() *TableColumn { + o := &TableColumn{} + o.SetTypeName("Forms$TableColumn") + o.width = property.NewPrimitive[int32]("Width", property.DecodeInt32) + o.width.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.width, }) + return o +} + +// NewTableColumn creates a new TableColumn for user code. Marked dirty (bit 63 = new element). +func NewTableColumn() *TableColumn { + o := initTableColumn() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTableRow creates a TableRow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTableRow() *TableRow { + o := &TableRow{} + o.SetTypeName("Forms$TableRow") + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 0) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 1) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 2) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.class, o.style, o.appearance, o.conditionalVisibilitySettings, }) + return o +} + +// NewTableRow creates a new TableRow for user code. Marked dirty (bit 63 = new element). +func NewTableRow() *TableRow { + o := initTableRow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTemplateGrid creates a TemplateGrid with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTemplateGrid() *TemplateGrid { + o := &TemplateGrid{} + o.SetTypeName("Forms$TemplateGrid") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.dataSource = property.NewPart[element.Element]("DataSource") + o.dataSource.Bind(&o.Base, 7) + o.isControlBarVisible = property.NewPrimitive[bool]("IsControlBarVisible", property.DecodeBool) + o.isControlBarVisible.Bind(&o.Base, 8) + o.isPagingEnabled = property.NewPrimitive[bool]("IsPagingEnabled", property.DecodeBool) + o.isPagingEnabled.Bind(&o.Base, 9) + o.showPagingBar = property.NewEnum[string]("ShowPagingBar") + o.showPagingBar.Bind(&o.Base, 10) + o.selectionMode = property.NewEnum[string]("SelectionMode") + o.selectionMode.Bind(&o.Base, 11) + o.selectFirst = property.NewPrimitive[bool]("SelectFirst", property.DecodeBool) + o.selectFirst.Bind(&o.Base, 12) + o.defaultButtonTrigger = property.NewEnum[string]("DefaultButtonTrigger") + o.defaultButtonTrigger.Bind(&o.Base, 13) + o.refreshTime = property.NewPrimitive[int32]("RefreshTime", property.DecodeInt32) + o.refreshTime.Bind(&o.Base, 14) + o.controlBar = property.NewPart[element.Element]("ControlBar") + o.controlBar.Bind(&o.Base, 15) + o.contents = property.NewPart[element.Element]("Contents") + o.contents.Bind(&o.Base, 16) + o.numberOfRows = property.NewPrimitive[int32]("NumberOfRows", property.DecodeInt32) + o.numberOfRows.Bind(&o.Base, 17) + o.numberOfColumns = property.NewPrimitive[int32]("NumberOfColumns", property.DecodeInt32) + o.numberOfColumns.Bind(&o.Base, 18) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.dataSource, o.isControlBarVisible, o.isPagingEnabled, o.showPagingBar, o.selectionMode, o.selectFirst, o.defaultButtonTrigger, o.refreshTime, o.controlBar, o.contents, o.numberOfRows, o.numberOfColumns, }) + return o +} + +// NewTemplateGrid creates a new TemplateGrid for user code. Marked dirty (bit 63 = new element). +func NewTemplateGrid() *TemplateGrid { + o := initTemplateGrid() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTemplateGridContents creates a TemplateGridContents with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTemplateGridContents() *TemplateGridContents { + o := &TemplateGridContents{} + o.SetTypeName("Forms$TemplateGridContents") + o.widget = property.NewPart[element.Element]("Widget") + o.widget.Bind(&o.Base, 0) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.widget, o.widgets, }) + return o +} + +// NewTemplateGridContents creates a new TemplateGridContents for user code. Marked dirty (bit 63 = new element). +func NewTemplateGridContents() *TemplateGridContents { + o := initTemplateGridContents() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTemplatePlaceholder creates a TemplatePlaceholder with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTemplatePlaceholder() *TemplatePlaceholder { + o := &TemplatePlaceholder{} + o.SetTypeName("Forms$TemplatePlaceholder") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.propType, }) + return o +} + +// NewTemplatePlaceholder creates a new TemplatePlaceholder for user code. Marked dirty (bit 63 = new element). +func NewTemplatePlaceholder() *TemplatePlaceholder { + o := initTemplatePlaceholder() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTextArea creates a TextArea with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTextArea() *TextArea { + o := &TextArea{} + o.SetTypeName("Forms$TextArea") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 7) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 8) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 9) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 10) + o.screenReaderLabel = property.NewPart[element.Element]("ScreenReaderLabel") + o.screenReaderLabel.Bind(&o.Base, 11) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 12) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 13) + o.readOnlyStyle = property.NewEnum[string]("ReadOnlyStyle") + o.readOnlyStyle.Bind(&o.Base, 14) + o.required = property.NewPrimitive[bool]("Required", property.DecodeBool) + o.required.Bind(&o.Base, 15) + o.requiredMessage = property.NewPart[element.Element]("RequiredMessage") + o.requiredMessage.Bind(&o.Base, 16) + o.validation = property.NewPart[element.Element]("Validation") + o.validation.Bind(&o.Base, 17) + o.onChangeMicroflowSettings = property.NewPart[element.Element]("OnChangeMicroflowSettings") + o.onChangeMicroflowSettings.Bind(&o.Base, 18) + o.onEnterMicroflowSettings = property.NewPart[element.Element]("OnEnterMicroflowSettings") + o.onEnterMicroflowSettings.Bind(&o.Base, 19) + o.onLeaveMicroflowSettings = property.NewPart[element.Element]("OnLeaveMicroflowSettings") + o.onLeaveMicroflowSettings.Bind(&o.Base, 20) + o.onChangeAction = property.NewPart[element.Element]("OnChangeAction") + o.onChangeAction.Bind(&o.Base, 21) + o.onEnterAction = property.NewPart[element.Element]("OnEnterAction") + o.onEnterAction.Bind(&o.Base, 22) + o.onLeaveAction = property.NewPart[element.Element]("OnLeaveAction") + o.onLeaveAction.Bind(&o.Base, 23) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 24) + o.ariaRequired = property.NewPrimitive[bool]("AriaRequired", property.DecodeBool) + o.ariaRequired.Bind(&o.Base, 25) + o.placeholder = property.NewPart[element.Element]("Placeholder") + o.placeholder.Bind(&o.Base, 26) + o.placeholderTemplate = property.NewPart[element.Element]("PlaceholderTemplate") + o.placeholderTemplate.Bind(&o.Base, 27) + o.maxLengthCode = property.NewPrimitive[int32]("MaxLengthCode", property.DecodeInt32) + o.maxLengthCode.Bind(&o.Base, 28) + o.autoFocus = property.NewPrimitive[bool]("AutoFocus", property.DecodeBool) + o.autoFocus.Bind(&o.Base, 29) + o.numberOfLines = property.NewPrimitive[int32]("NumberOfLines", property.DecodeInt32) + o.numberOfLines.Bind(&o.Base, 30) + o.counterMessage = property.NewPart[element.Element]("CounterMessage") + o.counterMessage.Bind(&o.Base, 31) + o.textTooLongMessage = property.NewPart[element.Element]("TextTooLongMessage") + o.textTooLongMessage.Bind(&o.Base, 32) + o.autocomplete = property.NewPrimitive[bool]("Autocomplete", property.DecodeBool) + o.autocomplete.Bind(&o.Base, 33) + o.submitBehaviour = property.NewEnum[string]("SubmitBehaviour") + o.submitBehaviour.Bind(&o.Base, 34) + o.submitOnInputDelay = property.NewPrimitive[int32]("SubmitOnInputDelay", property.DecodeInt32) + o.submitOnInputDelay.Bind(&o.Base, 35) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 36) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.conditionalEditabilitySettings, o.editable, o.label, o.labelTemplate, o.screenReaderLabel, o.attributePath, o.attributeRef, o.readOnlyStyle, o.required, o.requiredMessage, o.validation, o.onChangeMicroflowSettings, o.onEnterMicroflowSettings, o.onLeaveMicroflowSettings, o.onChangeAction, o.onEnterAction, o.onLeaveAction, o.sourceVariable, o.ariaRequired, o.placeholder, o.placeholderTemplate, o.maxLengthCode, o.autoFocus, o.numberOfLines, o.counterMessage, o.textTooLongMessage, o.autocomplete, o.submitBehaviour, o.submitOnInputDelay, o.nativeAccessibilitySettings, }) + return o +} + +// NewTextArea creates a new TextArea for user code. Marked dirty (bit 63 = new element). +func NewTextArea() *TextArea { + o := initTextArea() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTextBox creates a TextBox with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTextBox() *TextBox { + o := &TextBox{} + o.SetTypeName("Forms$TextBox") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.conditionalEditabilitySettings = property.NewPart[element.Element]("ConditionalEditabilitySettings") + o.conditionalEditabilitySettings.Bind(&o.Base, 7) + o.editable = property.NewEnum[string]("Editable") + o.editable.Bind(&o.Base, 8) + o.label = property.NewPart[element.Element]("Label") + o.label.Bind(&o.Base, 9) + o.labelTemplate = property.NewPart[element.Element]("LabelTemplate") + o.labelTemplate.Bind(&o.Base, 10) + o.screenReaderLabel = property.NewPart[element.Element]("ScreenReaderLabel") + o.screenReaderLabel.Bind(&o.Base, 11) + o.attributePath = property.NewPrimitive[string]("AttributePath", property.DecodeString) + o.attributePath.Bind(&o.Base, 12) + o.attributeRef = property.NewPart[element.Element]("AttributeRef") + o.attributeRef.Bind(&o.Base, 13) + o.readOnlyStyle = property.NewEnum[string]("ReadOnlyStyle") + o.readOnlyStyle.Bind(&o.Base, 14) + o.required = property.NewPrimitive[bool]("Required", property.DecodeBool) + o.required.Bind(&o.Base, 15) + o.requiredMessage = property.NewPart[element.Element]("RequiredMessage") + o.requiredMessage.Bind(&o.Base, 16) + o.validation = property.NewPart[element.Element]("Validation") + o.validation.Bind(&o.Base, 17) + o.onChangeMicroflowSettings = property.NewPart[element.Element]("OnChangeMicroflowSettings") + o.onChangeMicroflowSettings.Bind(&o.Base, 18) + o.onEnterMicroflowSettings = property.NewPart[element.Element]("OnEnterMicroflowSettings") + o.onEnterMicroflowSettings.Bind(&o.Base, 19) + o.onLeaveMicroflowSettings = property.NewPart[element.Element]("OnLeaveMicroflowSettings") + o.onLeaveMicroflowSettings.Bind(&o.Base, 20) + o.onChangeAction = property.NewPart[element.Element]("OnChangeAction") + o.onChangeAction.Bind(&o.Base, 21) + o.onEnterAction = property.NewPart[element.Element]("OnEnterAction") + o.onEnterAction.Bind(&o.Base, 22) + o.onLeaveAction = property.NewPart[element.Element]("OnLeaveAction") + o.onLeaveAction.Bind(&o.Base, 23) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 24) + o.ariaRequired = property.NewPrimitive[bool]("AriaRequired", property.DecodeBool) + o.ariaRequired.Bind(&o.Base, 25) + o.placeholder = property.NewPart[element.Element]("Placeholder") + o.placeholder.Bind(&o.Base, 26) + o.placeholderTemplate = property.NewPart[element.Element]("PlaceholderTemplate") + o.placeholderTemplate.Bind(&o.Base, 27) + o.maxLengthCode = property.NewPrimitive[int32]("MaxLengthCode", property.DecodeInt32) + o.maxLengthCode.Bind(&o.Base, 28) + o.autoFocus = property.NewPrimitive[bool]("AutoFocus", property.DecodeBool) + o.autoFocus.Bind(&o.Base, 29) + o.inputMask = property.NewPrimitive[string]("InputMask", property.DecodeString) + o.inputMask.Bind(&o.Base, 30) + o.formattingInfo = property.NewPart[element.Element]("FormattingInfo") + o.formattingInfo.Bind(&o.Base, 31) + o.isPasswordBox = property.NewPrimitive[bool]("IsPasswordBox", property.DecodeBool) + o.isPasswordBox.Bind(&o.Base, 32) + o.keyboardType = property.NewEnum[string]("KeyboardType") + o.keyboardType.Bind(&o.Base, 33) + o.onEnterKeyPressAction = property.NewPart[element.Element]("OnEnterKeyPressAction") + o.onEnterKeyPressAction.Bind(&o.Base, 34) + o.autocomplete = property.NewPrimitive[bool]("Autocomplete", property.DecodeBool) + o.autocomplete.Bind(&o.Base, 35) + o.autocompletePurpose = property.NewEnum[string]("AutocompletePurpose") + o.autocompletePurpose.Bind(&o.Base, 36) + o.submitBehaviour = property.NewEnum[string]("SubmitBehaviour") + o.submitBehaviour.Bind(&o.Base, 37) + o.submitOnInputDelay = property.NewPrimitive[int32]("SubmitOnInputDelay", property.DecodeInt32) + o.submitOnInputDelay.Bind(&o.Base, 38) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 39) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.conditionalEditabilitySettings, o.editable, o.label, o.labelTemplate, o.screenReaderLabel, o.attributePath, o.attributeRef, o.readOnlyStyle, o.required, o.requiredMessage, o.validation, o.onChangeMicroflowSettings, o.onEnterMicroflowSettings, o.onLeaveMicroflowSettings, o.onChangeAction, o.onEnterAction, o.onLeaveAction, o.sourceVariable, o.ariaRequired, o.placeholder, o.placeholderTemplate, o.maxLengthCode, o.autoFocus, o.inputMask, o.formattingInfo, o.isPasswordBox, o.keyboardType, o.onEnterKeyPressAction, o.autocomplete, o.autocompletePurpose, o.submitBehaviour, o.submitOnInputDelay, o.nativeAccessibilitySettings, }) + return o +} + +// NewTextBox creates a new TextBox for user code. Marked dirty (bit 63 = new element). +func NewTextBox() *TextBox { + o := initTextBox() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTitle creates a Title with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTitle() *Title { + o := &Title{} + o.SetTypeName("Forms$Title") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.conditionalVisibilitySettings = property.NewPart[element.Element]("ConditionalVisibilitySettings") + o.conditionalVisibilitySettings.Bind(&o.Base, 5) + o.accessibilitySettings = property.NewPart[element.Element]("AccessibilitySettings") + o.accessibilitySettings.Bind(&o.Base, 6) + o.nativeAccessibilitySettings = property.NewPart[element.Element]("NativeAccessibilitySettings") + o.nativeAccessibilitySettings.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.conditionalVisibilitySettings, o.accessibilitySettings, o.nativeAccessibilitySettings, }) + return o +} + +// NewTitle creates a new Title for user code. Marked dirty (bit 63 = new element). +func NewTitle() *Title { + o := initTitle() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initToggleDesignPropertyValue creates a ToggleDesignPropertyValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initToggleDesignPropertyValue() *ToggleDesignPropertyValue { + o := &ToggleDesignPropertyValue{} + o.SetTypeName("Forms$ToggleDesignPropertyValue") + o.SetProperties([]element.Property{}) + return o +} + +// NewToggleDesignPropertyValue creates a new ToggleDesignPropertyValue for user code. Marked dirty (bit 63 = new element). +func NewToggleDesignPropertyValue() *ToggleDesignPropertyValue { + o := initToggleDesignPropertyValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUserRoleSet creates a UserRoleSet with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUserRoleSet() *UserRoleSet { + o := &UserRoleSet{} + o.SetTypeName("Forms$UserRoleSet") + o.userRoles = property.NewByNameRefList[element.Element]("UserRoles", "Security$UserRole") + o.userRoles.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.userRoles, }) + return o +} + +// NewUserRoleSet creates a new UserRoleSet for user code. Marked dirty (bit 63 = new element). +func NewUserRoleSet() *UserRoleSet { + o := initUserRoleSet() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUserTaskTemplateType creates a UserTaskTemplateType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUserTaskTemplateType() *UserTaskTemplateType { + o := &UserTaskTemplateType{} + o.SetTypeName("Forms$UserTaskTemplateType") + o.SetProperties([]element.Property{}) + return o +} + +// NewUserTaskTemplateType creates a new UserTaskTemplateType for user code. Marked dirty (bit 63 = new element). +func NewUserTaskTemplateType() *UserTaskTemplateType { + o := initUserTaskTemplateType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initValidationMessage creates a ValidationMessage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initValidationMessage() *ValidationMessage { + o := &ValidationMessage{} + o.SetTypeName("Forms$ValidationMessage") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, }) + return o +} + +// NewValidationMessage creates a new ValidationMessage for user code. Marked dirty (bit 63 = new element). +func NewValidationMessage() *ValidationMessage { + o := initValidationMessage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initVerticalFlow creates a VerticalFlow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initVerticalFlow() *VerticalFlow { + o := &VerticalFlow{} + o.SetTypeName("Forms$VerticalFlow") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.widgets, }) + return o +} + +// NewVerticalFlow creates a new VerticalFlow for user code. Marked dirty (bit 63 = new element). +func NewVerticalFlow() *VerticalFlow { + o := initVerticalFlow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initVerticalSplitPane creates a VerticalSplitPane with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initVerticalSplitPane() *VerticalSplitPane { + o := &VerticalSplitPane{} + o.SetTypeName("Forms$VerticalSplitPane") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.firstWidget = property.NewPart[element.Element]("FirstWidget") + o.firstWidget.Bind(&o.Base, 5) + o.secondWidget = property.NewPart[element.Element]("SecondWidget") + o.secondWidget.Bind(&o.Base, 6) + o.firstWidgets = property.NewPartList[element.Element]("FirstWidgets") + o.firstWidgets.Bind(&o.Base, 7) + o.secondWidgets = property.NewPartList[element.Element]("SecondWidgets") + o.secondWidgets.Bind(&o.Base, 8) + o.animatedResize = property.NewPrimitive[bool]("AnimatedResize", property.DecodeBool) + o.animatedResize.Bind(&o.Base, 9) + o.height = property.NewPrimitive[int32]("Height", property.DecodeInt32) + o.height.Bind(&o.Base, 10) + o.position = property.NewPrimitive[int32]("Position", property.DecodeInt32) + o.position.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.firstWidget, o.secondWidget, o.firstWidgets, o.secondWidgets, o.animatedResize, o.height, o.position, }) + return o +} + +// NewVerticalSplitPane creates a new VerticalSplitPane for user code. Marked dirty (bit 63 = new element). +func NewVerticalSplitPane() *VerticalSplitPane { + o := initVerticalSplitPane() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWebLayoutContent creates a WebLayoutContent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWebLayoutContent() *WebLayoutContent { + o := &WebLayoutContent{} + o.SetTypeName("Forms$WebLayoutContent") + o.layoutType = property.NewEnum[string]("LayoutType") + o.layoutType.Bind(&o.Base, 0) + o.layoutCall = property.NewPart[element.Element]("LayoutCall") + o.layoutCall.Bind(&o.Base, 1) + o.widgets = property.NewPartList[element.Element]("Widgets") + o.widgets.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.layoutType, o.layoutCall, o.widgets, }) + return o +} + +// NewWebLayoutContent creates a new WebLayoutContent for user code. Marked dirty (bit 63 = new element). +func NewWebLayoutContent() *WebLayoutContent { + o := initWebLayoutContent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWidgetValidation creates a WidgetValidation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWidgetValidation() *WidgetValidation { + o := &WidgetValidation{} + o.SetTypeName("Forms$WidgetValidation") + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 0) + o.expressionModel = property.NewPart[element.Element]("ExpressionModel") + o.expressionModel.Bind(&o.Base, 1) + o.message = property.NewPart[element.Element]("Message") + o.message.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.expression, o.expressionModel, o.message, }) + return o +} + +// NewWidgetValidation creates a new WidgetValidation for user code. Marked dirty (bit 63 = new element). +func NewWidgetValidation() *WidgetValidation { + o := initWidgetValidation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowOverviewTemplateType creates a WorkflowOverviewTemplateType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowOverviewTemplateType() *WorkflowOverviewTemplateType { + o := &WorkflowOverviewTemplateType{} + o.SetTypeName("Forms$WorkflowOverviewTemplateType") + o.SetProperties([]element.Property{}) + return o +} + +// NewWorkflowOverviewTemplateType creates a new WorkflowOverviewTemplateType for user code. Marked dirty (bit 63 = new element). +func NewWorkflowOverviewTemplateType() *WorkflowOverviewTemplateType { + o := initWorkflowOverviewTemplateType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + + +func init() { + codec.DefaultRegistry.Register("Forms$AccessibilitySettings", func() element.Element { + return initAccessibilitySettings() + }) + codec.DefaultRegistry.Register("Forms$ActionButton", func() element.Element { + return initActionButton() + }) + codec.DefaultRegistry.Register("Forms$Appearance", func() element.Element { + return initAppearance() + }) + codec.DefaultRegistry.Register("Forms$AssociationSource", func() element.Element { + return initAssociationSource() + }) + codec.DefaultRegistry.Register("Forms$BackButton", func() element.Element { + return initBackButton() + }) + codec.DefaultRegistry.Register("Forms$BuildingBlock", func() element.Element { + return initBuildingBlock() + }) + codec.DefaultRegistry.Register("Forms$CallNanoflowClientAction", func() element.Element { + return initCallNanoflowClientAction() + }) + codec.DefaultRegistry.Register("Forms$CallWorkflowClientAction", func() element.Element { + return initCallWorkflowClientAction() + }) + codec.DefaultRegistry.Register("Forms$CancelButton", func() element.Element { + return initCancelButton() + }) + codec.DefaultRegistry.Register("Forms$CancelChangesClientAction", func() element.Element { + return initCancelChangesClientAction() + }) + codec.DefaultRegistry.Register("Forms$CancelSynchronizationClientAction", func() element.Element { + return initCancelSynchronizationClientAction() + }) + codec.DefaultRegistry.Register("Forms$CheckBox", func() element.Element { + return initCheckBox() + }) + codec.DefaultRegistry.Register("Forms$ClientTemplate", func() element.Element { + return initClientTemplate() + }) + codec.DefaultRegistry.Register("Forms$ClientTemplateParameter", func() element.Element { + return initClientTemplateParameter() + }) + codec.DefaultRegistry.Register("Forms$ClosePageClientAction", func() element.Element { + return initClosePageClientAction() + }) + codec.DefaultRegistry.Register("Forms$ComparisonSearchField", func() element.Element { + return initComparisonSearchField() + }) + codec.DefaultRegistry.Register("Forms$CompoundDesignPropertyValue", func() element.Element { + return initCompoundDesignPropertyValue() + }) + codec.DefaultRegistry.Register("Forms$ConditionalEditabilitySettings", func() element.Element { + return initConditionalEditabilitySettings() + }) + codec.DefaultRegistry.Register("Forms$ConditionalVisibilitySettings", func() element.Element { + return initConditionalVisibilitySettings() + }) + codec.DefaultRegistry.Register("Forms$ConfirmationInfo", func() element.Element { + return initConfirmationInfo() + }) + codec.DefaultRegistry.Register("Forms$CreateObjectClientAction", func() element.Element { + return initCreateObjectClientAction() + }) + codec.DefaultRegistry.Register("Forms$CustomDesignPropertyValue", func() element.Element { + return initCustomDesignPropertyValue() + }) + codec.DefaultRegistry.Register("Forms$DataGrid", func() element.Element { + return initDataGrid() + }) + codec.DefaultRegistry.Register("Forms$DataGridAddButton", func() element.Element { + return initDataGridAddButton() + }) + codec.DefaultRegistry.Register("Forms$DataGridExportToCSVButton", func() element.Element { + return initDataGridExportToCSVButton() + }) + codec.DefaultRegistry.Register("Forms$DataGridExportToExcelButton", func() element.Element { + return initDataGridExportToExcelButton() + }) + codec.DefaultRegistry.Register("Forms$DataGridRemoveButton", func() element.Element { + return initDataGridRemoveButton() + }) + codec.DefaultRegistry.Register("Forms$DataView", func() element.Element { + return initDataView() + }) + codec.DefaultRegistry.Register("Forms$DataViewActionButton", func() element.Element { + return initDataViewActionButton() + }) + codec.DefaultRegistry.Register("Forms$DataViewCancelButton", func() element.Element { + return initDataViewCancelButton() + }) + codec.DefaultRegistry.Register("Forms$DataViewCloseButton", func() element.Element { + return initDataViewCloseButton() + }) + codec.DefaultRegistry.Register("Forms$DataViewControlBar", func() element.Element { + return initDataViewControlBar() + }) + codec.DefaultRegistry.Register("Forms$DataViewSaveButton", func() element.Element { + return initDataViewSaveButton() + }) + codec.DefaultRegistry.Register("Forms$DataViewSource", func() element.Element { + return initDataViewSource() + }) + codec.DefaultRegistry.Register("Forms$DatabaseConstraint", func() element.Element { + return initDatabaseConstraint() + }) + codec.DefaultRegistry.Register("Forms$DatePicker", func() element.Element { + return initDatePicker() + }) + codec.DefaultRegistry.Register("Forms$DeleteClientAction", func() element.Element { + return initDeleteClientAction() + }) + codec.DefaultRegistry.Register("Forms$DesignPropertyValue", func() element.Element { + return initDesignPropertyValue() + }) + codec.DefaultRegistry.Register("Forms$DivContainer", func() element.Element { + return initDivContainer() + }) + codec.DefaultRegistry.Register("Forms$DropDown", func() element.Element { + return initDropDown() + }) + codec.DefaultRegistry.Register("Forms$DropDownButton", func() element.Element { + return initDropDownButton() + }) + codec.DefaultRegistry.Register("Forms$DropDownButtonItem", func() element.Element { + return initDropDownButtonItem() + }) + codec.DefaultRegistry.Register("Forms$DropDownSearchField", func() element.Element { + return initDropDownSearchField() + }) + codec.DefaultRegistry.Register("Forms$DynamicImageViewer", func() element.Element { + o := initDynamicImageViewer() + o.SetTypeName("Forms$DynamicImageViewer") + return o + }) + codec.DefaultRegistry.Register("Forms$ImageViewer", func() element.Element { + return initDynamicImageViewer() + }) + codec.DefaultRegistry.Register("Forms$DynamicText", func() element.Element { + return initDynamicText() + }) + codec.DefaultRegistry.Register("Forms$EditPageTemplateType", func() element.Element { + return initEditPageTemplateType() + }) + codec.DefaultRegistry.Register("Forms$FileManager", func() element.Element { + return initFileManager() + }) + codec.DefaultRegistry.Register("Forms$FormattingInfo", func() element.Element { + return initFormattingInfo() + }) + codec.DefaultRegistry.Register("Forms$GlyphIcon", func() element.Element { + return initGlyphIcon() + }) + codec.DefaultRegistry.Register("Forms$GridActionButton", func() element.Element { + return initGridActionButton() + }) + codec.DefaultRegistry.Register("Forms$GridColumn", func() element.Element { + return initGridColumn() + }) + codec.DefaultRegistry.Register("Forms$GridControlBar", func() element.Element { + return initGridControlBar() + }) + codec.DefaultRegistry.Register("Forms$GridDatabaseSource", func() element.Element { + return initGridDatabaseSource() + }) + codec.DefaultRegistry.Register("Forms$GridDeleteButton", func() element.Element { + return initGridDeleteButton() + }) + codec.DefaultRegistry.Register("Forms$GridDeselectAllButton", func() element.Element { + return initGridDeselectAllButton() + }) + codec.DefaultRegistry.Register("Forms$GridEditButton", func() element.Element { + return initGridEditButton() + }) + codec.DefaultRegistry.Register("Forms$GridNewButton", func() element.Element { + return initGridNewButton() + }) + codec.DefaultRegistry.Register("Forms$GridSearchButton", func() element.Element { + return initGridSearchButton() + }) + codec.DefaultRegistry.Register("Forms$GridSelectAllButton", func() element.Element { + return initGridSelectAllButton() + }) + codec.DefaultRegistry.Register("Forms$GridSortBar", func() element.Element { + return initGridSortBar() + }) + codec.DefaultRegistry.Register("Forms$GridSortItem", func() element.Element { + return initGridSortItem() + }) + codec.DefaultRegistry.Register("Forms$GridXPathSource", func() element.Element { + return initGridXPathSource() + }) + codec.DefaultRegistry.Register("Forms$GroupBox", func() element.Element { + return initGroupBox() + }) + codec.DefaultRegistry.Register("Forms$Header", func() element.Element { + return initHeader() + }) + codec.DefaultRegistry.Register("Forms$HorizontalSplitPane", func() element.Element { + return initHorizontalSplitPane() + }) + codec.DefaultRegistry.Register("Forms$IconCollectionIcon", func() element.Element { + return initIconCollectionIcon() + }) + codec.DefaultRegistry.Register("Forms$ImageIcon", func() element.Element { + return initImageIcon() + }) + codec.DefaultRegistry.Register("Forms$ImageUploader", func() element.Element { + return initImageUploader() + }) + codec.DefaultRegistry.Register("Forms$ImageViewerSource", func() element.Element { + return initImageViewerSource() + }) + codec.DefaultRegistry.Register("Forms$InputReferenceSetSelector", func() element.Element { + return initInputReferenceSetSelector() + }) + codec.DefaultRegistry.Register("Forms$Label", func() element.Element { + return initLabel() + }) + codec.DefaultRegistry.Register("Forms$Layout", func() element.Element { + return initLayout() + }) + codec.DefaultRegistry.Register("Forms$LayoutCall", func() element.Element { + return initLayoutCall() + }) + codec.DefaultRegistry.Register("Forms$LayoutCallArgument", func() element.Element { + return initLayoutCallArgument() + }) + codec.DefaultRegistry.Register("Forms$LayoutGrid", func() element.Element { + return initLayoutGrid() + }) + codec.DefaultRegistry.Register("Forms$LayoutGridColumn", func() element.Element { + return initLayoutGridColumn() + }) + codec.DefaultRegistry.Register("Forms$LayoutGridRow", func() element.Element { + return initLayoutGridRow() + }) + codec.DefaultRegistry.Register("Forms$LinkButton", func() element.Element { + return initLinkButton() + }) + codec.DefaultRegistry.Register("Forms$ListView", func() element.Element { + return initListView() + }) + codec.DefaultRegistry.Register("Forms$ListViewDatabaseSource", func() element.Element { + return initListViewDatabaseSource() + }) + codec.DefaultRegistry.Register("Forms$ListViewSearch", func() element.Element { + return initListViewSearch() + }) + codec.DefaultRegistry.Register("Forms$ListViewTemplate", func() element.Element { + return initListViewTemplate() + }) + codec.DefaultRegistry.Register("Forms$ListViewXPathSource", func() element.Element { + return initListViewXPathSource() + }) + codec.DefaultRegistry.Register("Forms$ListenTargetSource", func() element.Element { + return initListenTargetSource() + }) + codec.DefaultRegistry.Register("Forms$LocalVariable", func() element.Element { + return initLocalVariable() + }) + codec.DefaultRegistry.Register("Forms$LoginButton", func() element.Element { + return initLoginButton() + }) + codec.DefaultRegistry.Register("Forms$LoginIdTextBox", func() element.Element { + return initLoginIdTextBox() + }) + codec.DefaultRegistry.Register("Forms$LogoutButton", func() element.Element { + return initLogoutButton() + }) + codec.DefaultRegistry.Register("Forms$MasterDetail", func() element.Element { + return initMasterDetail() + }) + codec.DefaultRegistry.Register("Forms$MasterDetailDetailRegion", func() element.Element { + return initMasterDetailDetailRegion() + }) + codec.DefaultRegistry.Register("Forms$MasterDetailMasterRegion", func() element.Element { + return initMasterDetailMasterRegion() + }) + codec.DefaultRegistry.Register("Forms$MenuBar", func() element.Element { + return initMenuBar() + }) + codec.DefaultRegistry.Register("Forms$MenuDocumentSource", func() element.Element { + return initMenuDocumentSource() + }) + codec.DefaultRegistry.Register("Forms$MicroflowClientAction", func() element.Element { + o := initMicroflowClientAction() + o.SetTypeName("Forms$MicroflowClientAction") + return o + }) + codec.DefaultRegistry.Register("Forms$MicroflowAction", func() element.Element { + return initMicroflowClientAction() + }) + codec.DefaultRegistry.Register("Forms$MicroflowParameterMapping", func() element.Element { + return initMicroflowParameterMapping() + }) + codec.DefaultRegistry.Register("Forms$MicroflowSettings", func() element.Element { + return initMicroflowSettings() + }) + codec.DefaultRegistry.Register("Forms$MicroflowSource", func() element.Element { + return initMicroflowSource() + }) + codec.DefaultRegistry.Register("Forms$NamedValue", func() element.Element { + return initNamedValue() + }) + codec.DefaultRegistry.Register("Forms$NanoflowParameterMapping", func() element.Element { + return initNanoflowParameterMapping() + }) + codec.DefaultRegistry.Register("Forms$NanoflowSource", func() element.Element { + return initNanoflowSource() + }) + codec.DefaultRegistry.Register("Forms$NativeLayoutContent", func() element.Element { + return initNativeLayoutContent() + }) + codec.DefaultRegistry.Register("Forms$NavigationList", func() element.Element { + return initNavigationList() + }) + codec.DefaultRegistry.Register("Forms$NavigationListItem", func() element.Element { + return initNavigationListItem() + }) + codec.DefaultRegistry.Register("Forms$NavigationSource", func() element.Element { + return initNavigationSource() + }) + codec.DefaultRegistry.Register("Forms$NavigationTree", func() element.Element { + return initNavigationTree() + }) + codec.DefaultRegistry.Register("Forms$NewButton", func() element.Element { + return initNewButton() + }) + codec.DefaultRegistry.Register("Forms$NoClientAction", func() element.Element { + o := initNoClientAction() + o.SetTypeName("Forms$NoClientAction") + return o + }) + codec.DefaultRegistry.Register("Forms$NoAction", func() element.Element { + return initNoClientAction() + }) + codec.DefaultRegistry.Register("Forms$OfflineSchema", func() element.Element { + return initOfflineSchema() + }) + codec.DefaultRegistry.Register("Forms$OfflineSchemaFetchInstruction", func() element.Element { + return initOfflineSchemaFetchInstruction() + }) + codec.DefaultRegistry.Register("Forms$OnClickEnlarge", func() element.Element { + return initOnClickEnlarge() + }) + codec.DefaultRegistry.Register("Forms$OnClickMicroflow", func() element.Element { + return initOnClickMicroflow() + }) + codec.DefaultRegistry.Register("Forms$OnClickNothing", func() element.Element { + return initOnClickNothing() + }) + codec.DefaultRegistry.Register("Forms$OpenLinkClientAction", func() element.Element { + return initOpenLinkClientAction() + }) + codec.DefaultRegistry.Register("Forms$OpenUserTaskClientAction", func() element.Element { + return initOpenUserTaskClientAction() + }) + codec.DefaultRegistry.Register("Forms$OpenWorkflowClientAction", func() element.Element { + return initOpenWorkflowClientAction() + }) + codec.DefaultRegistry.Register("Forms$OptionDesignPropertyValue", func() element.Element { + return initOptionDesignPropertyValue() + }) + codec.DefaultRegistry.Register("Forms$OutputMapping", func() element.Element { + return initOutputMapping() + }) + codec.DefaultRegistry.Register("Forms$OverviewPageTemplateType", func() element.Element { + return initOverviewPageTemplateType() + }) + codec.DefaultRegistry.Register("Forms$Page", func() element.Element { + return initPage() + }) + codec.DefaultRegistry.Register("Forms$PageClientAction", func() element.Element { + o := initPageClientAction() + o.SetTypeName("Forms$PageClientAction") + return o + }) + codec.DefaultRegistry.Register("Forms$FormAction", func() element.Element { + return initPageClientAction() + }) + codec.DefaultRegistry.Register("Forms$PageForSpecialization", func() element.Element { + o := initPageForSpecialization() + o.SetTypeName("Forms$PageForSpecialization") + return o + }) + codec.DefaultRegistry.Register("Forms$FormForSpecialization", func() element.Element { + return initPageForSpecialization() + }) + codec.DefaultRegistry.Register("Forms$PageParameter", func() element.Element { + return initPageParameter() + }) + codec.DefaultRegistry.Register("Forms$PageParameterMapping", func() element.Element { + o := initPageParameterMapping() + o.SetTypeName("Forms$PageParameterMapping") + return o + }) + codec.DefaultRegistry.Register("Forms$FormCallArgument", func() element.Element { + return initPageParameterMapping() + }) + codec.DefaultRegistry.Register("Forms$PagePrimitiveParameterUrlSegment", func() element.Element { + return initPagePrimitiveParameterUrlSegment() + }) + codec.DefaultRegistry.Register("Forms$PageSettings", func() element.Element { + o := initPageSettings() + o.SetTypeName("Forms$PageSettings") + return o + }) + codec.DefaultRegistry.Register("Forms$FormSettings", func() element.Element { + return initPageSettings() + }) + codec.DefaultRegistry.Register("Forms$PageTemplate", func() element.Element { + return initPageTemplate() + }) + codec.DefaultRegistry.Register("Forms$PageVariable", func() element.Element { + return initPageVariable() + }) + codec.DefaultRegistry.Register("Forms$ParameterAttributeUrlSegment", func() element.Element { + return initParameterAttributeUrlSegment() + }) + codec.DefaultRegistry.Register("Forms$ParameterIdUrlSegment", func() element.Element { + return initParameterIdUrlSegment() + }) + codec.DefaultRegistry.Register("Forms$PasswordTextBox", func() element.Element { + return initPasswordTextBox() + }) + codec.DefaultRegistry.Register("Forms$Placeholder", func() element.Element { + return initPlaceholder() + }) + codec.DefaultRegistry.Register("Forms$RadioButtonGroup", func() element.Element { + return initRadioButtonGroup() + }) + codec.DefaultRegistry.Register("Forms$RangeSearchField", func() element.Element { + return initRangeSearchField() + }) + codec.DefaultRegistry.Register("Forms$ReferenceSelector", func() element.Element { + return initReferenceSelector() + }) + codec.DefaultRegistry.Register("Forms$ReferenceSetSelector", func() element.Element { + return initReferenceSetSelector() + }) + codec.DefaultRegistry.Register("Forms$ReferenceSetSource", func() element.Element { + return initReferenceSetSource() + }) + codec.DefaultRegistry.Register("Forms$RegularPageTemplateType", func() element.Element { + return initRegularPageTemplateType() + }) + codec.DefaultRegistry.Register("Forms$RetrievalQuery", func() element.Element { + return initRetrievalQuery() + }) + codec.DefaultRegistry.Register("Forms$RetrievalQueryParameter", func() element.Element { + return initRetrievalQueryParameter() + }) + codec.DefaultRegistry.Register("Forms$RetrievalSchema", func() element.Element { + return initRetrievalSchema() + }) + codec.DefaultRegistry.Register("Forms$RuntimeOperation", func() element.Element { + return initRuntimeOperation() + }) + codec.DefaultRegistry.Register("Forms$SaveButton", func() element.Element { + return initSaveButton() + }) + codec.DefaultRegistry.Register("Forms$SaveChangesClientAction", func() element.Element { + return initSaveChangesClientAction() + }) + codec.DefaultRegistry.Register("Forms$ScrollContainer", func() element.Element { + return initScrollContainer() + }) + codec.DefaultRegistry.Register("Forms$ScrollContainerRegion", func() element.Element { + return initScrollContainerRegion() + }) + codec.DefaultRegistry.Register("Forms$SearchBar", func() element.Element { + return initSearchBar() + }) + codec.DefaultRegistry.Register("Forms$SelectButton", func() element.Element { + return initSelectButton() + }) + codec.DefaultRegistry.Register("Forms$SelectPageTemplateType", func() element.Element { + return initSelectPageTemplateType() + }) + codec.DefaultRegistry.Register("Forms$SelectorDatabaseSource", func() element.Element { + return initSelectorDatabaseSource() + }) + codec.DefaultRegistry.Register("Forms$SelectorMicroflowSource", func() element.Element { + return initSelectorMicroflowSource() + }) + codec.DefaultRegistry.Register("Forms$SelectorXPathSource", func() element.Element { + return initSelectorXPathSource() + }) + codec.DefaultRegistry.Register("Forms$SetTaskOutcomeClientAction", func() element.Element { + return initSetTaskOutcomeClientAction() + }) + codec.DefaultRegistry.Register("Forms$SidebarToggleButton", func() element.Element { + return initSidebarToggleButton() + }) + codec.DefaultRegistry.Register("Forms$SignOutClientAction", func() element.Element { + return initSignOutClientAction() + }) + codec.DefaultRegistry.Register("Forms$SimpleMenuBar", func() element.Element { + return initSimpleMenuBar() + }) + codec.DefaultRegistry.Register("Forms$Snippet", func() element.Element { + return initSnippet() + }) + codec.DefaultRegistry.Register("Forms$SnippetCall", func() element.Element { + return initSnippetCall() + }) + codec.DefaultRegistry.Register("Forms$SnippetCallWidget", func() element.Element { + return initSnippetCallWidget() + }) + codec.DefaultRegistry.Register("Forms$SnippetParameter", func() element.Element { + return initSnippetParameter() + }) + codec.DefaultRegistry.Register("Forms$SnippetParameterMapping", func() element.Element { + return initSnippetParameterMapping() + }) + codec.DefaultRegistry.Register("Forms$StaticImageViewer", func() element.Element { + return initStaticImageViewer() + }) + codec.DefaultRegistry.Register("Forms$StaticOrDynamicString", func() element.Element { + return initStaticOrDynamicString() + }) + codec.DefaultRegistry.Register("Forms$StaticUrlSegment", func() element.Element { + return initStaticUrlSegment() + }) + codec.DefaultRegistry.Register("Forms$SyncButton", func() element.Element { + return initSyncButton() + }) + codec.DefaultRegistry.Register("Forms$SyncClientAction", func() element.Element { + return initSyncClientAction() + }) + codec.DefaultRegistry.Register("Forms$TabContainer", func() element.Element { + o := initTabContainer() + o.SetTypeName("Forms$TabContainer") + return o + }) + codec.DefaultRegistry.Register("Forms$TabControl", func() element.Element { + return initTabContainer() + }) + codec.DefaultRegistry.Register("Forms$TabPage", func() element.Element { + return initTabPage() + }) + codec.DefaultRegistry.Register("Forms$Table", func() element.Element { + return initTable() + }) + codec.DefaultRegistry.Register("Forms$TableCell", func() element.Element { + return initTableCell() + }) + codec.DefaultRegistry.Register("Forms$TableColumn", func() element.Element { + return initTableColumn() + }) + codec.DefaultRegistry.Register("Forms$TableRow", func() element.Element { + return initTableRow() + }) + codec.DefaultRegistry.Register("Forms$TemplateGrid", func() element.Element { + return initTemplateGrid() + }) + codec.DefaultRegistry.Register("Forms$TemplateGridContents", func() element.Element { + return initTemplateGridContents() + }) + codec.DefaultRegistry.Register("Forms$TemplatePlaceholder", func() element.Element { + return initTemplatePlaceholder() + }) + codec.DefaultRegistry.Register("Forms$TextArea", func() element.Element { + return initTextArea() + }) + codec.DefaultRegistry.Register("Forms$TextBox", func() element.Element { + return initTextBox() + }) + codec.DefaultRegistry.Register("Forms$Title", func() element.Element { + return initTitle() + }) + codec.DefaultRegistry.Register("Forms$ToggleDesignPropertyValue", func() element.Element { + return initToggleDesignPropertyValue() + }) + codec.DefaultRegistry.Register("Forms$UserRoleSet", func() element.Element { + return initUserRoleSet() + }) + codec.DefaultRegistry.Register("Forms$UserTaskTemplateType", func() element.Element { + return initUserTaskTemplateType() + }) + codec.DefaultRegistry.Register("Forms$ValidationMessage", func() element.Element { + return initValidationMessage() + }) + codec.DefaultRegistry.Register("Forms$VerticalFlow", func() element.Element { + return initVerticalFlow() + }) + codec.DefaultRegistry.Register("Forms$VerticalSplitPane", func() element.Element { + return initVerticalSplitPane() + }) + codec.DefaultRegistry.Register("Forms$WebLayoutContent", func() element.Element { + return initWebLayoutContent() + }) + codec.DefaultRegistry.Register("Forms$WidgetValidation", func() element.Element { + return initWidgetValidation() + }) + codec.DefaultRegistry.Register("Forms$WorkflowOverviewTemplateType", func() element.Element { + return initWorkflowOverviewTemplateType() + }) +} diff --git a/modelsdk/gen/pages/version.go b/modelsdk/gen/pages/version.go new file mode 100644 index 00000000..506d0cc1 --- /dev/null +++ b/modelsdk/gen/pages/version.go @@ -0,0 +1,1055 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package pages + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Forms$AccessibilitySettings": { + Properties: map[string]version.PropertyVersionInfo{ + "accessible": {Deleted: "9.24.0"}, + "screenReaderDescription": {Required: true}, + "screenReaderTitle": {Required: true}, + }, + }, + "Forms$Widget": { + Properties: map[string]version.PropertyVersionInfo{ + "appearance": {Introduced: "8.0.0", Required: true}, + "class": {Deleted: "8.0.0"}, + "style": {Deleted: "8.0.0"}, + }, + }, + "Forms$ConditionallyVisibleWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "accessibilitySettings": {Introduced: "9.22.0", Deleted: "9.24.0"}, + }, + }, + "Forms$Button": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + "tooltip": {Required: true}, + }, + }, + "Forms$ActionButton": { + Properties: map[string]version.PropertyVersionInfo{ + "action": {Required: true}, + "ariaRole": {Introduced: "9.0.1"}, + "disabledDuringAction": {Deleted: "8.12.0"}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + }, + }, + "Forms$ActionItem": { + Properties: map[string]version.PropertyVersionInfo{ + "action": {Required: true}, + }, + }, + "Forms$Appearance": { + Properties: map[string]version.PropertyVersionInfo{ + "dynamicClasses": {Introduced: "8.13.0"}, + }, + }, + "Forms$DataSource": { + Properties: map[string]version.PropertyVersionInfo{ + "forceFullObjects": {Introduced: "10.8.0"}, + }, + }, + "Forms$EntityPathSource": { + Properties: map[string]version.PropertyVersionInfo{ + "entityPath": {Deleted: "7.11.0"}, + "entityRef": {Introduced: "7.11.0"}, + "sourceVariable": {Introduced: "10.0.0"}, + }, + }, + "Forms$InputWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "label": {Deleted: "7.18.0"}, + "labelTemplate": {Introduced: "7.18.0"}, + "screenReaderLabel": {Introduced: "8.12.0"}, + }, + }, + "Forms$MemberWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "attributePath": {Deleted: "7.11.0"}, + "attributeRef": {Introduced: "7.11.0"}, + "readOnlyStyle": {Introduced: "6.9.0"}, + }, + }, + "Forms$AssociationWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "onChangeAction": {Introduced: "7.13.0", Required: true}, + "onChangeMicroflowSettings": {Deleted: "7.13.0", Required: true}, + "selectPageSettings": {Required: true}, + "selectorSource": {Required: true}, + "sourceVariable": {Introduced: "9.24.0"}, + }, + }, + "Forms$AttributeWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "ariaRequired": {Introduced: "9.2.0"}, + "onChangeAction": {Introduced: "7.13.0", Required: true}, + "onChangeMicroflowSettings": {Deleted: "7.13.0", Required: true}, + "onEnterAction": {Introduced: "7.13.0", Required: true}, + "onEnterMicroflowSettings": {Deleted: "7.13.0", Required: true}, + "onLeaveAction": {Introduced: "7.13.0", Required: true}, + "onLeaveMicroflowSettings": {Deleted: "7.13.0", Required: true}, + "requiredMessage": {Deleted: "7.6.0", Required: true}, + "sourceVariable": {Introduced: "8.8.0"}, + "validation": {Introduced: "7.6.0", Required: true}, + }, + }, + "Forms$AttributeWidgetWithPlaceholder": { + Properties: map[string]version.PropertyVersionInfo{ + "placeholder": {Deleted: "10.11.0", Required: true}, + "placeholderTemplate": {Introduced: "10.11.0", Required: true}, + }, + }, + "Forms$TemplateFormBase": { + Properties: map[string]version.PropertyVersionInfo{ + "displayName": {Public: true}, + "documentationUrl": {Introduced: "7.17.0", Public: true}, + "templateCategory": {Introduced: "9.0.2", Public: true}, + "templateCategoryWeight": {Introduced: "9.0.2", Public: true}, + }, + }, + "Forms$BuildingBlock": { + Properties: map[string]version.PropertyVersionInfo{ + "platform": {Introduced: "8.3.0", Public: true}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$ClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "disabledDuringExecution": {Introduced: "8.12.0"}, + }, + }, + "Forms$CallNanoflowClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "nanoflow": {Introduced: "7.10.0"}, + "outputMappings": {Introduced: "11.5.0"}, + "parameterMappings": {Introduced: "7.19.0"}, + }, + }, + "Forms$CallWorkflowClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "commit": {Deleted: "9.12.0"}, + "confirmationInfo": {Introduced: "9.12.0"}, + }, + }, + "Forms$CancelButton": { + Properties: map[string]version.PropertyVersionInfo{ + "closePage": {Introduced: "6.7.0"}, + }, + }, + "Forms$CheckBox": { + Properties: map[string]version.PropertyVersionInfo{ + "labelPosition": {Introduced: "8.0.0"}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + "nativeRenderMode": {Introduced: "9.8.0"}, + }, + }, + "Forms$ClientTemplate": { + Properties: map[string]version.PropertyVersionInfo{ + "fallback": {Introduced: "8.3.0", Required: true}, + "template": {Required: true}, + }, + }, + "Forms$ClientTemplateParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "attributePath": {Deleted: "7.11.0"}, + "attributeRef": {Introduced: "7.11.0"}, + "expression": {Introduced: "9.0.1"}, + "formattingInfo": {Introduced: "7.15.0", Required: true}, + "sourceVariable": {Introduced: "9.24.0"}, + }, + }, + "Forms$ClosePageClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "numberOfPages": {Introduced: "8.9.0", Deleted: "8.14.0"}, + "numberOfPagesToClose": {Introduced: "8.14.0"}, + }, + }, + "Forms$EntityWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "dataSource": {Required: true}, + }, + }, + "Forms$Grid": { + Properties: map[string]version.PropertyVersionInfo{ + "controlBar": {Required: true}, + "isPagingEnabled": {Deleted: "8.13.0"}, + "showPagingBar": {Introduced: "8.13.0"}, + }, + }, + "Forms$SearchField": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + "customDateFormat": {Introduced: "7.21.0"}, + "placeholder": {Introduced: "7.21.0", Required: true}, + }, + }, + "Forms$SingleSearchField": { + Properties: map[string]version.PropertyVersionInfo{ + "attributePath": {Deleted: "7.11.0"}, + "attributeRef": {Introduced: "7.11.0"}, + }, + }, + "Forms$ConditionalSettings": { + Properties: map[string]version.PropertyVersionInfo{ + "expression": {Introduced: "7.0.1"}, + "expressionModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "sourceVariable": {Introduced: "9.24.0"}, + }, + }, + "Forms$ConfirmationInfo": { + Properties: map[string]version.PropertyVersionInfo{ + "cancelButtonCaption": {Required: true}, + "proceedButtonCaption": {Required: true}, + "question": {Required: true}, + }, + }, + "Forms$ControlBarButton": { + Properties: map[string]version.PropertyVersionInfo{ + "appearance": {Introduced: "8.0.0", Required: true}, + "caption": {Required: true}, + "class": {Deleted: "8.0.0"}, + "style": {Deleted: "8.0.0"}, + "tooltip": {Required: true}, + }, + }, + "Forms$CreateObjectClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "numberOfPagesToClose": {Introduced: "8.11.0", Deleted: "8.14.0"}, + "numberOfPagesToClose2": {Introduced: "8.14.0"}, + "pageSettings": {Required: true}, + }, + }, + "Forms$DataGrid": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Introduced: "8.0.0", Required: true}, + }, + }, + "Forms$DataGridAddButton": { + Properties: map[string]version.PropertyVersionInfo{ + "pageSettings": {Required: true}, + }, + }, + "Forms$DataView": { + Properties: map[string]version.PropertyVersionInfo{ + "closeOnSaveOrCancel": {Deleted: "6.7.0"}, + "conditionalEditabilitySettings": {Introduced: "10.7.0"}, + "controlBar": {Deleted: "6.7.0"}, + "editability": {Introduced: "10.7.0"}, + "editable": {Deleted: "10.7.0"}, + "footerWidget": {Introduced: "6.7.0", Deleted: "7.15.0"}, + "footerWidgets": {Introduced: "7.15.0"}, + "noEntityMessage": {Required: true}, + "readOnlyStyle": {Introduced: "6.9.0"}, + "showControlBar": {Deleted: "6.7.0"}, + "showFooter": {Introduced: "6.7.0"}, + "useSchema": {Deleted: "8.0.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$DataViewActionButton": { + Properties: map[string]version.PropertyVersionInfo{ + "action": {Required: true}, + }, + }, + "Forms$DataViewSaveButton": { + Properties: map[string]version.PropertyVersionInfo{ + "syncAutomatically": {Introduced: "6.6.0"}, + }, + }, + "Forms$DataViewSource": { + Properties: map[string]version.PropertyVersionInfo{ + "pageParameter": {Introduced: "9.5.0", Deleted: "10.2.0"}, + "snippetParameter": {Introduced: "9.21.0", Deleted: "10.2.0"}, + }, + }, + "Forms$SortableEntityPathSource": { + Properties: map[string]version.PropertyVersionInfo{ + "sortBar": {Required: true}, + }, + }, + "Forms$DatePicker": { + Properties: map[string]version.PropertyVersionInfo{ + "formattingInfo": {Required: true}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + }, + }, + "Forms$DeleteClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "sourceVariable": {Introduced: "10.4.0"}, + }, + }, + "Forms$DesignPropertyValue": { + Properties: map[string]version.PropertyVersionInfo{ + "booleanValue": {Deleted: "10.2.0"}, + "stringValue": {Deleted: "10.2.0"}, + "type": {Deleted: "10.2.0"}, + "value": {Introduced: "10.2.0"}, + }, + }, + "Forms$DivContainer": { + Properties: map[string]version.PropertyVersionInfo{ + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + "onClickAction": {Introduced: "8.3.0", Required: true}, + "renderMode": {Introduced: "7.23.0"}, + "screenReaderHidden": {Introduced: "8.12.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$DropDown": { + Properties: map[string]version.PropertyVersionInfo{ + "emptyOptionCaption": {Introduced: "7.2.0", Required: true}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + }, + }, + "Forms$DropDownButtonItem": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + }, + }, + "Forms$DropDownSearchField": { + Properties: map[string]version.PropertyVersionInfo{ + "sortBar": {Required: true}, + }, + }, + "Forms$DynamicImageViewer": { + Properties: map[string]version.PropertyVersionInfo{ + "alternativeText": {Introduced: "8.6.0", Required: true}, + "clickAction": {Introduced: "7.18.0", Required: true}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + "onClickEnlarge": {Introduced: "7.18.0"}, + "showAsThumbnail": {Deleted: "7.18.0", Required: true}, + "widthUnit": {}, + }, + }, + "Forms$ImageViewer": { + Properties: map[string]version.PropertyVersionInfo{ + "alternativeText": {Introduced: "8.6.0", Required: true}, + "clickAction": {Introduced: "7.18.0", Required: true}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + "onClickEnlarge": {Introduced: "7.18.0"}, + "showAsThumbnail": {Deleted: "7.18.0", Required: true}, + "widthUnit": {}, + }, + }, + "Forms$DynamicText": { + Properties: map[string]version.PropertyVersionInfo{ + "content": {Required: true}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + "nativeTextStyle": {Introduced: "8.0.0"}, + }, + }, + "Forms$GridActionButton": { + Properties: map[string]version.PropertyVersionInfo{ + "action": {Required: true}, + }, + }, + "Forms$GridBaseSource": { + Properties: map[string]version.PropertyVersionInfo{ + "searchBar": {Required: true}, + }, + }, + "Forms$GridColumn": { + Properties: map[string]version.PropertyVersionInfo{ + "aggregateCaption": {Required: true}, + "appearance": {Introduced: "8.0.0", Required: true}, + "attributePath": {Deleted: "7.11.0"}, + "attributeRef": {Introduced: "7.11.0"}, + "caption": {Required: true}, + "class": {Deleted: "8.0.0"}, + "formattingInfo": {Required: true}, + "style": {Deleted: "8.0.0"}, + }, + }, + "Forms$GridControlBar": { + Properties: map[string]version.PropertyVersionInfo{ + "searchButton": {Deleted: "7.13.0", Required: true}, + }, + }, + "Forms$GridDatabaseSource": { + Properties: map[string]version.PropertyVersionInfo{ + "searchBar": {Required: true}, + }, + }, + "Forms$GridEditButton": { + Properties: map[string]version.PropertyVersionInfo{ + "pageSettings": {Required: true}, + }, + }, + "Forms$GridNewButton": { + Properties: map[string]version.PropertyVersionInfo{ + "isPersistent": {Deleted: "6.2.0"}, + "pageSettings": {Required: true}, + }, + }, + "Forms$GridSortItem": { + Properties: map[string]version.PropertyVersionInfo{ + "attributePath": {Deleted: "7.11.0", Required: true}, + "attributeRef": {Introduced: "7.11.0", Required: true}, + }, + }, + "Forms$GridXPathSource": { + Properties: map[string]version.PropertyVersionInfo{ + "applyContext": {Deleted: "8.0.0"}, + "removeAllFromContext": {Deleted: "8.0.0"}, + "removeFromContextIds": {Deleted: "8.0.0"}, + }, + }, + "Forms$GroupBox": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Introduced: "8.10.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$Header": { + Properties: map[string]version.PropertyVersionInfo{ + "leftWidget": {Deleted: "7.15.0"}, + "leftWidgets": {Introduced: "7.15.0"}, + "rightWidget": {Deleted: "7.15.0"}, + "rightWidgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$SplitPane": { + Properties: map[string]version.PropertyVersionInfo{ + "firstWidget": {Deleted: "7.15.0"}, + "firstWidgets": {Introduced: "7.15.0"}, + "secondWidget": {Deleted: "7.15.0"}, + "secondWidgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$IconCollectionIcon": { + Properties: map[string]version.PropertyVersionInfo{ + "image": {Required: true}, + }, + }, + "Forms$ImageIcon": { + Properties: map[string]version.PropertyVersionInfo{ + "image": {Required: true}, + }, + }, + "Forms$Label": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + }, + }, + "Forms$Layout": { + Properties: map[string]version.PropertyVersionInfo{ + "acceptButtonPlaceholder": {Deleted: "6.8.0"}, + "acceptPlaceholderName": {Introduced: "6.8.0", Deleted: "7.9.0"}, + "appearance": {Introduced: "8.0.0", Required: true}, + "cancelButtonPlaceholder": {Deleted: "6.8.0"}, + "cancelPlaceholderName": {Introduced: "6.8.0", Deleted: "7.9.0"}, + "class": {Deleted: "8.0.0"}, + "content": {Introduced: "8.0.0", Required: true, Public: true}, + "layoutCall": {Deleted: "8.0.0", Public: true}, + "layoutType": {Deleted: "8.0.0", Public: true}, + "mainPlaceholder": {Deleted: "6.8.0"}, + "mainPlaceholderName": {Introduced: "6.8.0", Deleted: "7.9.0"}, + "style": {Deleted: "8.0.0"}, + "useMainPlaceholderForPopups": {Deleted: "7.9.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0", Deleted: "8.0.0"}, + }, + }, + "Forms$LayoutCall": { + Properties: map[string]version.PropertyVersionInfo{ + "layout": {Required: true, Public: true}, + }, + }, + "Forms$LayoutCallArgument": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Introduced: "6.8.0", Required: true}, + "parameterName": {Deleted: "6.8.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$LayoutGrid": { + Properties: map[string]version.PropertyVersionInfo{ + "rows": {}, + }, + }, + "Forms$LayoutGridColumn": { + Properties: map[string]version.PropertyVersionInfo{ + "appearance": {Introduced: "8.0.0", Required: true}, + "class": {Deleted: "8.0.0"}, + "phoneWeight": {Introduced: "8.3.0"}, + "previewWidth": {Introduced: "9.16.0"}, + "style": {Deleted: "8.0.0"}, + "tabletWeight": {Introduced: "8.3.0"}, + "verticalAlignment": {Introduced: "8.3.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$LayoutGridRow": { + Properties: map[string]version.PropertyVersionInfo{ + "appearance": {Introduced: "8.0.0", Required: true}, + "columns": {Deleted: "8.0.0"}, + "horizontalAlignment": {Introduced: "8.3.0"}, + "spacingBetweenColumns": {Introduced: "8.3.0"}, + "style": {Deleted: "8.0.0"}, + "verticalAlignment": {Introduced: "8.3.0"}, + }, + }, + "Forms$LayoutParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + }, + }, + "Forms$LinkButton": { + Properties: map[string]version.PropertyVersionInfo{ + "address": {Required: true}, + }, + }, + "Forms$ListView": { + Properties: map[string]version.PropertyVersionInfo{ + "clickAction": {Required: true}, + "numberOfColumns": {Introduced: "8.0.0"}, + "pullDownAction": {Introduced: "8.0.0", Required: true}, + "scrollDirection": {Introduced: "8.0.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$ListViewDatabaseSource": { + Properties: map[string]version.PropertyVersionInfo{ + "search": {Required: true}, + }, + }, + "Forms$ListViewSearch": { + Properties: map[string]version.PropertyVersionInfo{ + "searchPaths": {Deleted: "7.11.0"}, + "searchRefs": {Introduced: "7.11.0"}, + }, + }, + "Forms$ListViewTemplate": { + Properties: map[string]version.PropertyVersionInfo{ + "specialization": {Required: true}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$ListViewXPathSource": { + Properties: map[string]version.PropertyVersionInfo{ + "search": {Required: true}, + }, + }, + "Forms$LocalVariable": { + Properties: map[string]version.PropertyVersionInfo{ + "defaultValue": {Introduced: "10.20.0"}, + "variableType": {Required: true}, + }, + }, + "Forms$LoginTextBox": { + Properties: map[string]version.PropertyVersionInfo{ + "placeholder": {Required: true}, + }, + }, + "Forms$MasterDetail": { + Properties: map[string]version.PropertyVersionInfo{ + "detail": {Required: true}, + "master": {Required: true}, + }, + }, + "Forms$MasterDetailDetailRegion": { + Properties: map[string]version.PropertyVersionInfo{ + "title": {Required: true}, + }, + }, + "Forms$MenuWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "menuSource": {Required: true}, + }, + }, + "Forms$MicroflowClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "microflowSettings": {Required: true}, + }, + }, + "Forms$MicroflowAction": { + Properties: map[string]version.PropertyVersionInfo{ + "microflowSettings": {Required: true}, + }, + }, + "Forms$MicroflowParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "expression": {Introduced: "10.10.0"}, + "parameter": {Required: true}, + "useAllPages": {Deleted: "8.4.0"}, + "variable": {Introduced: "8.4.0"}, + "widget": {Deleted: "8.4.0"}, + }, + }, + "Forms$MicroflowSettings": { + Properties: map[string]version.PropertyVersionInfo{ + "outputMappings": {Introduced: "11.5.0"}, + "parameterMappings": {Introduced: "7.19.0"}, + "useAllPages": {Deleted: "7.19.0"}, + }, + }, + "Forms$MicroflowSource": { + Properties: map[string]version.PropertyVersionInfo{ + "microflowSettings": {Required: true}, + }, + }, + "Forms$NanoflowParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "expression": {Introduced: "10.10.0"}, + "parameter": {Required: true}, + "useAllPages": {Deleted: "8.4.0"}, + "variable": {Introduced: "8.4.0"}, + "widget": {Deleted: "8.4.0"}, + }, + }, + "Forms$NanoflowSource": { + Properties: map[string]version.PropertyVersionInfo{ + "parameterMappings": {Introduced: "7.19.0"}, + }, + }, + "Forms$NativeLayoutContent": { + Properties: map[string]version.PropertyVersionInfo{ + "layoutType": {Introduced: "8.5.0", Public: true}, + "showBottomBar": {Introduced: "8.2.0"}, + "sidebar": {Introduced: "8.5.0"}, + "sidebarWidgets": {Introduced: "8.5.0"}, + }, + }, + "Forms$NavigationListItem": { + Properties: map[string]version.PropertyVersionInfo{ + "appearance": {Introduced: "8.0.0", Required: true}, + "class": {Deleted: "8.0.0"}, + "style": {Deleted: "8.0.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$NavigationSource": { + Properties: map[string]version.PropertyVersionInfo{ + "navigationProfile": {Introduced: "7.2.0", Required: true}, + "profileType": {Deleted: "7.2.0"}, + }, + }, + "Forms$NewButton": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Deleted: "6.3.0"}, + "entityPath": {Introduced: "6.3.0", Deleted: "7.11.0"}, + "entityRef": {Introduced: "7.11.0"}, + "pageSettings": {Required: true}, + }, + }, + "Forms$OfflineSchema": { + Properties: map[string]version.PropertyVersionInfo{ + "tables": {Introduced: "6.4.0"}, + }, + }, + "Forms$OnClickMicroflow": { + Properties: map[string]version.PropertyVersionInfo{ + "microflowSettings": {Required: true}, + }, + }, + "Forms$OpenLinkClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "address": {Required: true}, + }, + }, + "Forms$OpenUserTaskClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "assignOnOpen": {Introduced: "9.20.0"}, + "openWhenAssigned": {Introduced: "9.20.0"}, + }, + }, + "Forms$OpenWorkflowClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "defaultPage": {Introduced: "9.0.5"}, + }, + }, + "Forms$Page": { + Properties: map[string]version.PropertyVersionInfo{ + "allowedRoles": {Public: true}, + "appearance": {Introduced: "8.0.0", Required: true}, + "autofocus": {Introduced: "11.1.0"}, + "class": {Deleted: "8.0.0"}, + "layoutCall": {Required: true, Public: true}, + "parameters": {Introduced: "9.4.0", Public: true}, + "popupCloseAction": {Introduced: "6.7.0"}, + "style": {Deleted: "8.0.0"}, + "title": {Required: true}, + "url": {Introduced: "6.7.0"}, + "variables": {Introduced: "10.17.0"}, + }, + }, + "Forms$PageClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "numberOfPagesToClose": {Introduced: "8.11.0", Deleted: "8.14.0"}, + "numberOfPagesToClose2": {Introduced: "8.14.0"}, + "pageSettings": {Required: true}, + "pagesForSpecializations": {Introduced: "7.17.0"}, + }, + }, + "Forms$FormAction": { + Properties: map[string]version.PropertyVersionInfo{ + "numberOfPagesToClose": {Introduced: "8.11.0", Deleted: "8.14.0"}, + "numberOfPagesToClose2": {Introduced: "8.14.0"}, + "pageSettings": {Required: true}, + "pagesForSpecializations": {Introduced: "7.17.0"}, + }, + }, + "Forms$PageForSpecialization": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true}, + "pageSettings": {Required: true}, + }, + }, + "Forms$FormForSpecialization": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Required: true}, + "pageSettings": {Required: true}, + }, + }, + "Forms$PageParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "defaultValue": {Introduced: "11.5.0"}, + "isRequired": {Introduced: "11.5.0"}, + "name": {Public: true}, + "parameterType": {Required: true, Public: true}, + }, + }, + "Forms$PageParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true}, + "variable": {}, + }, + }, + "Forms$FormCallArgument": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true}, + "variable": {}, + }, + }, + "Forms$PagePrimitiveParameterUrlSegment": { + Properties: map[string]version.PropertyVersionInfo{ + "pageParameter": {Required: true}, + }, + }, + "Forms$PageSettings": { + Properties: map[string]version.PropertyVersionInfo{ + "formTitle": {Deleted: "8.12.0"}, + "location": {Deleted: "8.0.0"}, + "parameterMappings": {Introduced: "9.7.0"}, + "titleOverride": {Introduced: "8.12.0"}, + }, + }, + "Forms$FormSettings": { + Properties: map[string]version.PropertyVersionInfo{ + "formTitle": {Deleted: "8.12.0"}, + "location": {Deleted: "8.0.0"}, + "parameterMappings": {Introduced: "9.7.0"}, + "titleOverride": {Introduced: "8.12.0"}, + }, + }, + "Forms$PageTemplate": { + Properties: map[string]version.PropertyVersionInfo{ + "appearance": {Introduced: "8.0.0", Required: true}, + "class": {Deleted: "8.0.0"}, + "layoutCall": {Required: true, Public: true}, + "style": {Deleted: "8.0.0"}, + "templateType": {Introduced: "8.13.0", Required: true, Public: true}, + "type": {Deleted: "8.13.0", Public: true}, + }, + }, + "Forms$PageVariable": { + Properties: map[string]version.PropertyVersionInfo{ + "localVariable": {Introduced: "10.17.0"}, + "pageParameter": {Introduced: "9.5.0"}, + "snippetParameter": {Introduced: "9.21.0"}, + "subKey": {Introduced: "11.0.0"}, + }, + }, + "Forms$ParameterAttributeUrlSegment": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Required: true}, + "pageParameter": {Required: true}, + }, + }, + "Forms$ParameterIdUrlSegment": { + Properties: map[string]version.PropertyVersionInfo{ + "pageParameter": {Required: true}, + }, + }, + "Forms$RangeSearchField": { + Properties: map[string]version.PropertyVersionInfo{ + "lowerBound": {Deleted: "7.11.0"}, + "lowerBoundRef": {Introduced: "7.11.0"}, + "upperBound": {Deleted: "7.11.0"}, + "upperBoundRef": {Introduced: "7.11.0"}, + }, + }, + "Forms$ReferenceSelector": { + Properties: map[string]version.PropertyVersionInfo{ + "emptyOptionCaption": {Introduced: "7.2.0", Required: true}, + "formattingInfo": {Required: true}, + "gotoPageSettings": {Required: true}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + "requiredMessage": {Deleted: "7.6.0", Required: true}, + "validation": {Introduced: "7.6.0", Required: true}, + }, + }, + "Forms$ReferenceSetSelector": { + Properties: map[string]version.PropertyVersionInfo{ + "constrainedBy": {Deleted: "7.11.0"}, + "constrainedByRefs": {Introduced: "7.11.0"}, + "onChangeAction": {Introduced: "7.13.0", Required: true}, + "onChangeMicroflowSettings": {Deleted: "7.13.0", Required: true}, + "removeAllFromContext": {Deleted: "8.0.0"}, + "removeFromContextEntities": {Deleted: "8.0.0"}, + }, + }, + "Forms$RetrievalQuery": { + Properties: map[string]version.PropertyVersionInfo{ + "allowedUserRoleSets": {Introduced: "9.21.0"}, + "allowedUserRoles": {Deleted: "9.21.0"}, + "entityPath": {Introduced: "7.21.0"}, + "microflow": {Introduced: "7.21.0"}, + "pageName": {Introduced: "7.14.0"}, + "parameters": {Introduced: "8.6.0"}, + "schemaId": {Deleted: "8.4.0"}, + "usedAssociations": {Introduced: "8.4.0"}, + "usedAttributes": {Introduced: "8.11.0"}, + "widgetName": {Introduced: "8.4.0"}, + }, + }, + "Forms$RetrievalQueryParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "type": {Deleted: "10.0.0"}, + "types": {Introduced: "10.0.0"}, + }, + }, + "Forms$RetrievalSchema": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Deleted: "7.4.0"}, + "usedAssociations": {Introduced: "7.2.0"}, + "usedAttributes": {Deleted: "7.2.0"}, + "widgetName": {Introduced: "7.14.0"}, + }, + }, + "Forms$RuntimeOperation": { + Properties: map[string]version.PropertyVersionInfo{ + "allowedUserRoleSets": {Introduced: "9.21.0"}, + "allowedUserRoles": {Introduced: "9.18.0", Deleted: "9.21.0"}, + "constants": {Introduced: "9.24.0"}, + "operationName": {Introduced: "9.20.0", Deleted: "9.24.0"}, + }, + }, + "Forms$SaveButton": { + Properties: map[string]version.PropertyVersionInfo{ + "closePage": {Introduced: "6.7.0"}, + "syncAutomatically": {Introduced: "6.6.0"}, + }, + }, + "Forms$ScrollContainer": { + Properties: map[string]version.PropertyVersionInfo{ + "center": {Required: true}, + "nativeHideScrollbars": {Introduced: "9.11.0"}, + }, + }, + "Forms$ScrollContainerRegion": { + Properties: map[string]version.PropertyVersionInfo{ + "appearance": {Introduced: "8.0.0", Required: true}, + "class": {Deleted: "8.0.0"}, + "style": {Deleted: "8.0.0"}, + "toggleMode": {Introduced: "6.10.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$SelectorDatabaseSource": { + Properties: map[string]version.PropertyVersionInfo{ + "sortBar": {Introduced: "6.2.0", Required: true}, + }, + }, + "Forms$SelectorMicroflowSource": { + Properties: map[string]version.PropertyVersionInfo{ + "dataSourceMicroflowSettings": {Required: true}, + }, + }, + "Forms$SelectorXPathSource": { + Properties: map[string]version.PropertyVersionInfo{ + "applyContext": {Deleted: "8.0.0"}, + "constrainedBy": {Deleted: "7.11.0"}, + "constrainedByRefs": {Introduced: "7.11.0"}, + "removeAllFromContext": {Deleted: "8.0.0"}, + "removeFromContextEntities": {Deleted: "8.0.0"}, + "sortBar": {Required: true}, + }, + }, + "Forms$SetTaskOutcomeClientAction": { + Properties: map[string]version.PropertyVersionInfo{ + "outcome": {Deleted: "9.19.0"}, + "outcomeValue": {Introduced: "9.19.0"}, + }, + }, + "Forms$SidebarToggleButton": { + Properties: map[string]version.PropertyVersionInfo{ + "initiallyOpen": {Deleted: "6.10.0"}, + "mode": {Deleted: "6.10.0"}, + "region": {Deleted: "6.10.0"}, + }, + }, + "Forms$Snippet": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Deleted: "9.21.0", Public: true}, + "parameters": {Introduced: "9.21.0", Public: true}, + "type": {Introduced: "8.0.0", Public: true}, + "variables": {Introduced: "10.17.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$SnippetCall": { + Properties: map[string]version.PropertyVersionInfo{ + "parameterMappings": {Introduced: "9.21.0"}, + }, + }, + "Forms$SnippetCallWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "snippetCall": {Required: true}, + }, + }, + "Forms$SnippetParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "parameterType": {Required: true, Public: true}, + }, + }, + "Forms$SnippetParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "argument": {Introduced: "11.8.0"}, + "parameter": {Required: true}, + "variable": {}, + }, + }, + "Forms$StaticImageViewer": { + Properties: map[string]version.PropertyVersionInfo{ + "alternativeText": {Introduced: "8.6.0", Required: true}, + "clickAction": {Required: true}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + }, + }, + "Forms$StaticOrDynamicString": { + Properties: map[string]version.PropertyVersionInfo{ + "attribute": {Deleted: "7.11.0"}, + "attributeRef": {Introduced: "7.11.0"}, + }, + }, + "Forms$TabContainer": { + Properties: map[string]version.PropertyVersionInfo{ + "activePageAttributeRef": {Introduced: "10.14.0"}, + "activePageOnChangeAction": {Introduced: "10.14.0", Required: true}, + "activePageSourceVariable": {Introduced: "10.14.0"}, + }, + }, + "Forms$TabControl": { + Properties: map[string]version.PropertyVersionInfo{ + "activePageAttributeRef": {Introduced: "10.14.0"}, + "activePageOnChangeAction": {Introduced: "10.14.0", Required: true}, + "activePageSourceVariable": {Introduced: "10.14.0"}, + }, + }, + "Forms$TabPage": { + Properties: map[string]version.PropertyVersionInfo{ + "badge": {Introduced: "8.13.0"}, + "caption": {Required: true}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$Table": { + Properties: map[string]version.PropertyVersionInfo{ + "cells": {}, + "rows": {}, + }, + }, + "Forms$TableCell": { + Properties: map[string]version.PropertyVersionInfo{ + "appearance": {Introduced: "8.0.0", Required: true}, + "class": {Deleted: "8.0.0"}, + "style": {Deleted: "8.0.0"}, + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + "width": {}, + }, + }, + "Forms$TableRow": { + Properties: map[string]version.PropertyVersionInfo{ + "appearance": {Introduced: "8.0.0", Required: true}, + "class": {Deleted: "8.0.0"}, + "style": {Deleted: "8.0.0"}, + }, + }, + "Forms$TemplateGrid": { + Properties: map[string]version.PropertyVersionInfo{ + "contents": {Required: true}, + }, + }, + "Forms$TemplateGridContents": { + Properties: map[string]version.PropertyVersionInfo{ + "widget": {Deleted: "7.15.0"}, + "widgets": {Introduced: "7.15.0"}, + }, + }, + "Forms$TextWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "autoFocus": {Introduced: "9.15.0"}, + }, + }, + "Forms$TextArea": { + Properties: map[string]version.PropertyVersionInfo{ + "autocomplete": {Introduced: "8.10.0"}, + "counterMessage": {Required: true}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + "submitBehaviour": {Introduced: "9.14.0"}, + "submitOnInputDelay": {Introduced: "9.14.0"}, + "textTooLongMessage": {Required: true}, + }, + }, + "Forms$TextBox": { + Properties: map[string]version.PropertyVersionInfo{ + "autocomplete": {Introduced: "8.10.0"}, + "autocompletePurpose": {Introduced: "8.12.0"}, + "formattingInfo": {Required: true}, + "keyboardType": {Introduced: "8.0.0"}, + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + "onEnterKeyPressAction": {Introduced: "8.7.0", Required: true}, + "submitBehaviour": {Introduced: "8.15.0"}, + "submitOnInputDelay": {Introduced: "8.15.0"}, + }, + }, + "Forms$Title": { + Properties: map[string]version.PropertyVersionInfo{ + "nativeAccessibilitySettings": {Introduced: "9.24.0"}, + }, + }, + "Forms$WebLayoutContent": { + Properties: map[string]version.PropertyVersionInfo{ + "layoutCall": {Public: true}, + "layoutType": {Public: true}, + }, + }, + "Forms$WidgetValidation": { + Properties: map[string]version.PropertyVersionInfo{ + "expressionModel": {Introduced: "7.9.0", Deleted: "9.8.0", Required: true}, + "message": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/projects/enums.go b/modelsdk/gen/projects/enums.go new file mode 100644 index 00000000..0c8b5202 --- /dev/null +++ b/modelsdk/gen/projects/enums.go @@ -0,0 +1,29 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package projects + +// ExportLevel enumerates the possible values for the ExportLevel type. +type ExportLevel = string + +const ( + ExportLevelHidden ExportLevel = "Hidden" + ExportLevelAPI ExportLevel = "API" +) + +// ModuleExportLevel enumerates the possible values for the ModuleExportLevel type. +type ModuleExportLevel = string + +const ( + ModuleExportLevelSource ModuleExportLevel = "Source" + ModuleExportLevelProtected ModuleExportLevel = "Protected" +) + +// ProtectedModuleType enumerates the possible values for the ProtectedModuleType type. +type ProtectedModuleType = string + +const ( + ProtectedModuleTypeAddOn ProtectedModuleType = "AddOn" + ProtectedModuleTypeSolution ProtectedModuleType = "Solution" +) diff --git a/modelsdk/gen/projects/refs.go b/modelsdk/gen/projects/refs.go new file mode 100644 index 00000000..94c7d8c5 --- /dev/null +++ b/modelsdk/gen/projects/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package projects diff --git a/modelsdk/gen/projects/types.go b/modelsdk/gen/projects/types.go new file mode 100644 index 00000000..edf8aba3 --- /dev/null +++ b/modelsdk/gen/projects/types.go @@ -0,0 +1,1098 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package projects + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// ModuleDocument +// ──────────────────────────────────────────────────────── + +type ModuleDocument struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ModuleDocument) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Document +// ──────────────────────────────────────────────────────── + +type Document struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *Document) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Document) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Document) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Document) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Document) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Document) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Document) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Document) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Document) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// FolderBase +// ──────────────────────────────────────────────────────── + +type FolderBase struct { + element.Base + folders *property.PartList[element.Element] + documents *property.PartList[element.Element] +} + +// FoldersItems returns the value of the folders property. +func (o *FolderBase) FoldersItems() []element.Element { + return o.folders.Items() +} + +// AddFolders appends a child element to the folders list. +func (o *FolderBase) AddFolders(v element.Element) { + o.folders.Append(v) +} + +// RemoveFolders removes the element at the given index from the folders list. +func (o *FolderBase) RemoveFolders(index int) { + o.folders.Remove(index) +} + +// DocumentsItems returns the value of the documents property. +func (o *FolderBase) DocumentsItems() []element.Element { + return o.documents.Items() +} + +// AddDocuments appends a child element to the documents list. +func (o *FolderBase) AddDocuments(v element.Element) { + o.documents.Append(v) +} + +// RemoveDocuments removes the element at the given index from the documents list. +func (o *FolderBase) RemoveDocuments(index int) { + o.documents.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FolderBase) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Folders"); err == nil { + for _, child := range children { + o.folders.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Documents"); err == nil { + for _, child := range children { + o.documents.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Folder +// ──────────────────────────────────────────────────────── + +type Folder struct { + element.Base + folders *property.PartList[element.Element] + documents *property.PartList[element.Element] + name *property.Primitive[string] +} + +// FoldersItems returns the value of the folders property. +func (o *Folder) FoldersItems() []element.Element { + return o.folders.Items() +} + +// AddFolders appends a child element to the folders list. +func (o *Folder) AddFolders(v element.Element) { + o.folders.Append(v) +} + +// RemoveFolders removes the element at the given index from the folders list. +func (o *Folder) RemoveFolders(index int) { + o.folders.Remove(index) +} + +// DocumentsItems returns the value of the documents property. +func (o *Folder) DocumentsItems() []element.Element { + return o.documents.Items() +} + +// AddDocuments appends a child element to the documents list. +func (o *Folder) AddDocuments(v element.Element) { + o.documents.Append(v) +} + +// RemoveDocuments removes the element at the given index from the documents list. +func (o *Folder) RemoveDocuments(index int) { + o.documents.Remove(index) +} + +// Name returns the value of the name property. +func (o *Folder) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Folder) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Folder) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Folders"); err == nil { + for _, child := range children { + o.folders.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Documents"); err == nil { + for _, child := range children { + o.documents.AppendFromDecode(child) + } + } + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// JarDependency +// ──────────────────────────────────────────────────────── + +type JarDependency struct { + element.Base + groupId *property.Primitive[string] + artifactId *property.Primitive[string] + version *property.Primitive[string] + isIncluded *property.Primitive[bool] + exclusions *property.PartList[element.Element] +} + +// GroupId returns the value of the groupId property. +func (o *JarDependency) GroupId() string { + return o.groupId.Get() +} + +// SetGroupId sets the value of the groupId property. +func (o *JarDependency) SetGroupId(v string) { + o.groupId.Set(v) +} + +// ArtifactId returns the value of the artifactId property. +func (o *JarDependency) ArtifactId() string { + return o.artifactId.Get() +} + +// SetArtifactId sets the value of the artifactId property. +func (o *JarDependency) SetArtifactId(v string) { + o.artifactId.Set(v) +} + +// Version returns the value of the version property. +func (o *JarDependency) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *JarDependency) SetVersion(v string) { + o.version.Set(v) +} + +// IsIncluded returns the value of the isIncluded property. +func (o *JarDependency) IsIncluded() bool { + return o.isIncluded.Get() +} + +// SetIsIncluded sets the value of the isIncluded property. +func (o *JarDependency) SetIsIncluded(v bool) { + o.isIncluded.Set(v) +} + +// ExclusionsItems returns the value of the exclusions property. +func (o *JarDependency) ExclusionsItems() []element.Element { + return o.exclusions.Items() +} + +// AddExclusions appends a child element to the exclusions list. +func (o *JarDependency) AddExclusions(v element.Element) { + o.exclusions.Append(v) +} + +// RemoveExclusions removes the element at the given index from the exclusions list. +func (o *JarDependency) RemoveExclusions(index int) { + o.exclusions.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JarDependency) InitFromRaw(raw bson.Raw) { + o.groupId.Init(raw) + o.artifactId.Init(raw) + o.version.Init(raw) + o.isIncluded.Init(raw) + if children, err := codec.DecodeChildren(raw, "Exclusions"); err == nil { + for _, child := range children { + o.exclusions.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// JarDependencyExclusion +// ──────────────────────────────────────────────────────── + +type JarDependencyExclusion struct { + element.Base + groupId *property.Primitive[string] + artifactId *property.Primitive[string] +} + +// GroupId returns the value of the groupId property. +func (o *JarDependencyExclusion) GroupId() string { + return o.groupId.Get() +} + +// SetGroupId sets the value of the groupId property. +func (o *JarDependencyExclusion) SetGroupId(v string) { + o.groupId.Set(v) +} + +// ArtifactId returns the value of the artifactId property. +func (o *JarDependencyExclusion) ArtifactId() string { + return o.artifactId.Get() +} + +// SetArtifactId sets the value of the artifactId property. +func (o *JarDependencyExclusion) SetArtifactId(v string) { + o.artifactId.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JarDependencyExclusion) InitFromRaw(raw bson.Raw) { + o.groupId.Init(raw) + o.artifactId.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Module +// ──────────────────────────────────────────────────────── + +type Module struct { + element.Base + folders *property.PartList[element.Element] + documents *property.PartList[element.Element] + sortIndex *property.Primitive[float64] + name *property.Primitive[string] + domainModel *property.Part[element.Element] + moduleSettings *property.Part[element.Element] + moduleSecurity *property.Part[element.Element] + fromAppStore *property.Primitive[bool] + isReusableComponent *property.Primitive[bool] + appStoreGuid *property.Primitive[string] + appStoreVersionGuid *property.Primitive[string] + appStoreVersion *property.Primitive[string] + appStorePackageId *property.Primitive[int32] + appStorePackageIdString *property.Primitive[string] + exportLevel *property.Enum[string] + isThemeModule *property.Primitive[bool] +} + +// FoldersItems returns the value of the folders property. +func (o *Module) FoldersItems() []element.Element { + return o.folders.Items() +} + +// AddFolders appends a child element to the folders list. +func (o *Module) AddFolders(v element.Element) { + o.folders.Append(v) +} + +// RemoveFolders removes the element at the given index from the folders list. +func (o *Module) RemoveFolders(index int) { + o.folders.Remove(index) +} + +// DocumentsItems returns the value of the documents property. +func (o *Module) DocumentsItems() []element.Element { + return o.documents.Items() +} + +// AddDocuments appends a child element to the documents list. +func (o *Module) AddDocuments(v element.Element) { + o.documents.Append(v) +} + +// RemoveDocuments removes the element at the given index from the documents list. +func (o *Module) RemoveDocuments(index int) { + o.documents.Remove(index) +} + +// SortIndex returns the value of the sortIndex property. +func (o *Module) SortIndex() float64 { + return o.sortIndex.Get() +} + +// SetSortIndex sets the value of the sortIndex property. +func (o *Module) SetSortIndex(v float64) { + o.sortIndex.Set(v) +} + +// Name returns the value of the name property. +func (o *Module) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Module) SetName(v string) { + o.name.Set(v) +} + +// DomainModel returns the value of the domainModel property. +func (o *Module) DomainModel() element.Element { + return o.domainModel.Get() +} + +// SetDomainModel sets the value of the domainModel property. +func (o *Module) SetDomainModel(v element.Element) { + o.domainModel.Set(v) +} + +// ModuleSettings returns the value of the moduleSettings property. +func (o *Module) ModuleSettings() element.Element { + return o.moduleSettings.Get() +} + +// SetModuleSettings sets the value of the moduleSettings property. +func (o *Module) SetModuleSettings(v element.Element) { + o.moduleSettings.Set(v) +} + +// ModuleSecurity returns the value of the moduleSecurity property. +func (o *Module) ModuleSecurity() element.Element { + return o.moduleSecurity.Get() +} + +// SetModuleSecurity sets the value of the moduleSecurity property. +func (o *Module) SetModuleSecurity(v element.Element) { + o.moduleSecurity.Set(v) +} + +// FromAppStore returns the value of the fromAppStore property. +func (o *Module) FromAppStore() bool { + return o.fromAppStore.Get() +} + +// SetFromAppStore sets the value of the fromAppStore property. +func (o *Module) SetFromAppStore(v bool) { + o.fromAppStore.Set(v) +} + +// IsReusableComponent returns the value of the isReusableComponent property. +func (o *Module) IsReusableComponent() bool { + return o.isReusableComponent.Get() +} + +// SetIsReusableComponent sets the value of the isReusableComponent property. +func (o *Module) SetIsReusableComponent(v bool) { + o.isReusableComponent.Set(v) +} + +// AppStoreGuid returns the value of the appStoreGuid property. +func (o *Module) AppStoreGuid() string { + return o.appStoreGuid.Get() +} + +// SetAppStoreGuid sets the value of the appStoreGuid property. +func (o *Module) SetAppStoreGuid(v string) { + o.appStoreGuid.Set(v) +} + +// AppStoreVersionGuid returns the value of the appStoreVersionGuid property. +func (o *Module) AppStoreVersionGuid() string { + return o.appStoreVersionGuid.Get() +} + +// SetAppStoreVersionGuid sets the value of the appStoreVersionGuid property. +func (o *Module) SetAppStoreVersionGuid(v string) { + o.appStoreVersionGuid.Set(v) +} + +// AppStoreVersion returns the value of the appStoreVersion property. +func (o *Module) AppStoreVersion() string { + return o.appStoreVersion.Get() +} + +// SetAppStoreVersion sets the value of the appStoreVersion property. +func (o *Module) SetAppStoreVersion(v string) { + o.appStoreVersion.Set(v) +} + +// AppStorePackageId returns the value of the appStorePackageId property. +func (o *Module) AppStorePackageId() int32 { + return o.appStorePackageId.Get() +} + +// SetAppStorePackageId sets the value of the appStorePackageId property. +func (o *Module) SetAppStorePackageId(v int32) { + o.appStorePackageId.Set(v) +} + +// AppStorePackageIdString returns the value of the appStorePackageIdString property. +func (o *Module) AppStorePackageIdString() string { + return o.appStorePackageIdString.Get() +} + +// SetAppStorePackageIdString sets the value of the appStorePackageIdString property. +func (o *Module) SetAppStorePackageIdString(v string) { + o.appStorePackageIdString.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Module) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Module) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// IsThemeModule returns the value of the isThemeModule property. +func (o *Module) IsThemeModule() bool { + return o.isThemeModule.Get() +} + +// SetIsThemeModule sets the value of the isThemeModule property. +func (o *Module) SetIsThemeModule(v bool) { + o.isThemeModule.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Module) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Folders"); err == nil { + for _, child := range children { + o.folders.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Documents"); err == nil { + for _, child := range children { + o.documents.AppendFromDecode(child) + } + } + o.sortIndex.Init(raw) + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "DomainModel"); err == nil { + o.domainModel.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ModuleSettings"); err == nil { + o.moduleSettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ModuleSecurity"); err == nil { + o.moduleSecurity.SetFromDecode(child) + } + o.fromAppStore.Init(raw) + o.isReusableComponent.Init(raw) + o.appStoreGuid.Init(raw) + o.appStoreVersionGuid.Init(raw) + o.appStoreVersion.Init(raw) + o.appStorePackageId.Init(raw) + o.appStorePackageIdString.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.isThemeModule.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ModuleSettings +// ──────────────────────────────────────────────────────── + +type ModuleSettings struct { + element.Base + exportLevel *property.Enum[string] + protectedModuleType *property.Enum[string] + version *property.Primitive[string] + solutionIdentifier *property.Primitive[string] + extensionName *property.Primitive[string] + jarDependencies *property.PartList[element.Element] + basedOnVersion *property.Primitive[string] +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ModuleSettings) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ModuleSettings) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// ProtectedModuleType returns the value of the protectedModuleType property. +func (o *ModuleSettings) ProtectedModuleType() string { + return o.protectedModuleType.Get() +} + +// SetProtectedModuleType sets the value of the protectedModuleType property. +func (o *ModuleSettings) SetProtectedModuleType(v string) { + o.protectedModuleType.Set(v) +} + +// Version returns the value of the version property. +func (o *ModuleSettings) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *ModuleSettings) SetVersion(v string) { + o.version.Set(v) +} + +// SolutionIdentifier returns the value of the solutionIdentifier property. +func (o *ModuleSettings) SolutionIdentifier() string { + return o.solutionIdentifier.Get() +} + +// SetSolutionIdentifier sets the value of the solutionIdentifier property. +func (o *ModuleSettings) SetSolutionIdentifier(v string) { + o.solutionIdentifier.Set(v) +} + +// ExtensionName returns the value of the extensionName property. +func (o *ModuleSettings) ExtensionName() string { + return o.extensionName.Get() +} + +// SetExtensionName sets the value of the extensionName property. +func (o *ModuleSettings) SetExtensionName(v string) { + o.extensionName.Set(v) +} + +// JarDependenciesItems returns the value of the jarDependencies property. +func (o *ModuleSettings) JarDependenciesItems() []element.Element { + return o.jarDependencies.Items() +} + +// AddJarDependencies appends a child element to the jarDependencies list. +func (o *ModuleSettings) AddJarDependencies(v element.Element) { + o.jarDependencies.Append(v) +} + +// RemoveJarDependencies removes the element at the given index from the jarDependencies list. +func (o *ModuleSettings) RemoveJarDependencies(index int) { + o.jarDependencies.Remove(index) +} + +// BasedOnVersion returns the value of the basedOnVersion property. +func (o *ModuleSettings) BasedOnVersion() string { + return o.basedOnVersion.Get() +} + +// SetBasedOnVersion sets the value of the basedOnVersion property. +func (o *ModuleSettings) SetBasedOnVersion(v string) { + o.basedOnVersion.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ModuleSettings) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ProtectedModuleType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.protectedModuleType.SetFromDecode(s) + } + } + o.version.Init(raw) + o.solutionIdentifier.Init(raw) + o.extensionName.Init(raw) + if children, err := codec.DecodeChildren(raw, "JarDependencies"); err == nil { + for _, child := range children { + o.jarDependencies.AppendFromDecode(child) + } + } + o.basedOnVersion.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OneTimeConversionMarker +// ──────────────────────────────────────────────────────── + +type OneTimeConversionMarker struct { + element.Base + name *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *OneTimeConversionMarker) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *OneTimeConversionMarker) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OneTimeConversionMarker) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Project +// ──────────────────────────────────────────────────────── + +type Project struct { + element.Base + projectDocuments *property.PartList[element.Element] + modules *property.PartList[element.Element] + projectConversion *property.Part[element.Element] + isSystemProject *property.Primitive[bool] +} + +// ProjectDocumentsItems returns the value of the projectDocuments property. +func (o *Project) ProjectDocumentsItems() []element.Element { + return o.projectDocuments.Items() +} + +// AddProjectDocuments appends a child element to the projectDocuments list. +func (o *Project) AddProjectDocuments(v element.Element) { + o.projectDocuments.Append(v) +} + +// RemoveProjectDocuments removes the element at the given index from the projectDocuments list. +func (o *Project) RemoveProjectDocuments(index int) { + o.projectDocuments.Remove(index) +} + +// ModulesItems returns the value of the modules property. +func (o *Project) ModulesItems() []element.Element { + return o.modules.Items() +} + +// AddModules appends a child element to the modules list. +func (o *Project) AddModules(v element.Element) { + o.modules.Append(v) +} + +// RemoveModules removes the element at the given index from the modules list. +func (o *Project) RemoveModules(index int) { + o.modules.Remove(index) +} + +// ProjectConversion returns the value of the projectConversion property. +func (o *Project) ProjectConversion() element.Element { + return o.projectConversion.Get() +} + +// SetProjectConversion sets the value of the projectConversion property. +func (o *Project) SetProjectConversion(v element.Element) { + o.projectConversion.Set(v) +} + +// IsSystemProject returns the value of the isSystemProject property. +func (o *Project) IsSystemProject() bool { + return o.isSystemProject.Get() +} + +// SetIsSystemProject sets the value of the isSystemProject property. +func (o *Project) SetIsSystemProject(v bool) { + o.isSystemProject.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Project) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "ProjectDocuments"); err == nil { + for _, child := range children { + o.projectDocuments.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Modules"); err == nil { + for _, child := range children { + o.modules.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ProjectConversion"); err == nil { + o.projectConversion.SetFromDecode(child) + } + o.isSystemProject.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ProjectConversion +// ──────────────────────────────────────────────────────── + +type ProjectConversion struct { + element.Base + markers *property.PartList[element.Element] +} + +// MarkersItems returns the value of the markers property. +func (o *ProjectConversion) MarkersItems() []element.Element { + return o.markers.Items() +} + +// AddMarkers appends a child element to the markers list. +func (o *ProjectConversion) AddMarkers(v element.Element) { + o.markers.Append(v) +} + +// RemoveMarkers removes the element at the given index from the markers list. +func (o *ProjectConversion) RemoveMarkers(index int) { + o.markers.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ProjectConversion) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Markers"); err == nil { + for _, child := range children { + o.markers.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ProjectDocument +// ──────────────────────────────────────────────────────── + +type ProjectDocument struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ProjectDocument) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initFolder creates a Folder with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFolder() *Folder { + o := &Folder{} + o.SetTypeName("Projects$Folder") + o.folders = property.NewPartList[element.Element]("Folders") + o.folders.Bind(&o.Base, 0) + o.documents = property.NewPartList[element.Element]("Documents") + o.documents.Bind(&o.Base, 1) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.folders, o.documents, o.name}) + return o +} + +// NewFolder creates a new Folder for user code. Marked dirty (bit 63 = new element). +func NewFolder() *Folder { + o := initFolder() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJarDependency creates a JarDependency with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJarDependency() *JarDependency { + o := &JarDependency{} + o.SetTypeName("Projects$JarDependency") + o.groupId = property.NewPrimitive[string]("GroupId", property.DecodeString) + o.groupId.Bind(&o.Base, 0) + o.artifactId = property.NewPrimitive[string]("ArtifactId", property.DecodeString) + o.artifactId.Bind(&o.Base, 1) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 2) + o.isIncluded = property.NewPrimitive[bool]("IsIncluded", property.DecodeBool) + o.isIncluded.Bind(&o.Base, 3) + o.exclusions = property.NewPartList[element.Element]("Exclusions") + o.exclusions.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.groupId, o.artifactId, o.version, o.isIncluded, o.exclusions}) + return o +} + +// NewJarDependency creates a new JarDependency for user code. Marked dirty (bit 63 = new element). +func NewJarDependency() *JarDependency { + o := initJarDependency() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJarDependencyExclusion creates a JarDependencyExclusion with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJarDependencyExclusion() *JarDependencyExclusion { + o := &JarDependencyExclusion{} + o.SetTypeName("Projects$JarDependencyExclusion") + o.groupId = property.NewPrimitive[string]("GroupId", property.DecodeString) + o.groupId.Bind(&o.Base, 0) + o.artifactId = property.NewPrimitive[string]("ArtifactId", property.DecodeString) + o.artifactId.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.groupId, o.artifactId}) + return o +} + +// NewJarDependencyExclusion creates a new JarDependencyExclusion for user code. Marked dirty (bit 63 = new element). +func NewJarDependencyExclusion() *JarDependencyExclusion { + o := initJarDependencyExclusion() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initModule creates a Module with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initModule() *Module { + o := &Module{} + o.SetTypeName("Projects$ModuleImpl") + o.folders = property.NewPartList[element.Element]("Folders") + o.folders.Bind(&o.Base, 0) + o.documents = property.NewPartList[element.Element]("Documents") + o.documents.Bind(&o.Base, 1) + o.sortIndex = property.NewPrimitive[float64]("SortIndex", property.DecodeFloat64) + o.sortIndex.Bind(&o.Base, 2) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 3) + o.domainModel = property.NewPart[element.Element]("DomainModel") + o.domainModel.Bind(&o.Base, 4) + o.moduleSettings = property.NewPart[element.Element]("ModuleSettings") + o.moduleSettings.Bind(&o.Base, 5) + o.moduleSecurity = property.NewPart[element.Element]("ModuleSecurity") + o.moduleSecurity.Bind(&o.Base, 6) + o.fromAppStore = property.NewPrimitive[bool]("FromAppStore", property.DecodeBool) + o.fromAppStore.Bind(&o.Base, 7) + o.isReusableComponent = property.NewPrimitive[bool]("IsReusableComponent", property.DecodeBool) + o.isReusableComponent.Bind(&o.Base, 8) + o.appStoreGuid = property.NewPrimitive[string]("AppStoreGuid", property.DecodeString) + o.appStoreGuid.Bind(&o.Base, 9) + o.appStoreVersionGuid = property.NewPrimitive[string]("AppStoreVersionGuid", property.DecodeString) + o.appStoreVersionGuid.Bind(&o.Base, 10) + o.appStoreVersion = property.NewPrimitive[string]("AppStoreVersion", property.DecodeString) + o.appStoreVersion.Bind(&o.Base, 11) + o.appStorePackageId = property.NewPrimitive[int32]("AppStorePackageId", property.DecodeInt32) + o.appStorePackageId.Bind(&o.Base, 12) + o.appStorePackageIdString = property.NewPrimitive[string]("AppStorePackageIdString", property.DecodeString) + o.appStorePackageIdString.Bind(&o.Base, 13) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 14) + o.isThemeModule = property.NewPrimitive[bool]("IsThemeModule", property.DecodeBool) + o.isThemeModule.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.folders, o.documents, o.sortIndex, o.name, o.domainModel, o.moduleSettings, o.moduleSecurity, o.fromAppStore, o.isReusableComponent, o.appStoreGuid, o.appStoreVersionGuid, o.appStoreVersion, o.appStorePackageId, o.appStorePackageIdString, o.exportLevel, o.isThemeModule}) + return o +} + +// NewModule creates a new Module for user code. Marked dirty (bit 63 = new element). +func NewModule() *Module { + o := initModule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initModuleSettings creates a ModuleSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initModuleSettings() *ModuleSettings { + o := &ModuleSettings{} + o.SetTypeName("Projects$ModuleSettings") + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 0) + o.protectedModuleType = property.NewEnum[string]("ProtectedModuleType") + o.protectedModuleType.Bind(&o.Base, 1) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 2) + o.solutionIdentifier = property.NewPrimitive[string]("SolutionIdentifier", property.DecodeString) + o.solutionIdentifier.Bind(&o.Base, 3) + o.extensionName = property.NewPrimitive[string]("ExtensionName", property.DecodeString) + o.extensionName.Bind(&o.Base, 4) + o.jarDependencies = property.NewPartList[element.Element]("JarDependencies") + o.jarDependencies.Bind(&o.Base, 5) + o.basedOnVersion = property.NewPrimitive[string]("BasedOnVersion", property.DecodeString) + o.basedOnVersion.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.exportLevel, o.protectedModuleType, o.version, o.solutionIdentifier, o.extensionName, o.jarDependencies, o.basedOnVersion}) + return o +} + +// NewModuleSettings creates a new ModuleSettings for user code. Marked dirty (bit 63 = new element). +func NewModuleSettings() *ModuleSettings { + o := initModuleSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOneTimeConversionMarker creates a OneTimeConversionMarker with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOneTimeConversionMarker() *OneTimeConversionMarker { + o := &OneTimeConversionMarker{} + o.SetTypeName("Projects$OneTimeConversion") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.name}) + return o +} + +// NewOneTimeConversionMarker creates a new OneTimeConversionMarker for user code. Marked dirty (bit 63 = new element). +func NewOneTimeConversionMarker() *OneTimeConversionMarker { + o := initOneTimeConversionMarker() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initProject creates a Project with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initProject() *Project { + o := &Project{} + o.SetTypeName("Projects$Project") + o.projectDocuments = property.NewPartList[element.Element]("ProjectDocuments") + o.projectDocuments.Bind(&o.Base, 0) + o.modules = property.NewPartList[element.Element]("Modules") + o.modules.Bind(&o.Base, 1) + o.projectConversion = property.NewPart[element.Element]("ProjectConversion") + o.projectConversion.Bind(&o.Base, 2) + o.isSystemProject = property.NewPrimitive[bool]("IsSystemProject", property.DecodeBool) + o.isSystemProject.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.projectDocuments, o.modules, o.projectConversion, o.isSystemProject}) + return o +} + +// NewProject creates a new Project for user code. Marked dirty (bit 63 = new element). +func NewProject() *Project { + o := initProject() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initProjectConversion creates a ProjectConversion with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initProjectConversion() *ProjectConversion { + o := &ProjectConversion{} + o.SetTypeName("Projects$ProjectConversion") + o.markers = property.NewPartList[element.Element]("Markers") + o.markers.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.markers}) + return o +} + +// NewProjectConversion creates a new ProjectConversion for user code. Marked dirty (bit 63 = new element). +func NewProjectConversion() *ProjectConversion { + o := initProjectConversion() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Projects$Folder", func() element.Element { + return initFolder() + }) + codec.DefaultRegistry.Register("Projects$JarDependency", func() element.Element { + return initJarDependency() + }) + codec.DefaultRegistry.Register("Projects$JarDependencyExclusion", func() element.Element { + return initJarDependencyExclusion() + }) + codec.DefaultRegistry.Register("Projects$Module", func() element.Element { + o := initModule() + o.SetTypeName("Projects$Module") + return o + }) + codec.DefaultRegistry.Register("Projects$ModuleImpl", func() element.Element { + return initModule() + }) + codec.DefaultRegistry.Register("Projects$ModuleSettings", func() element.Element { + return initModuleSettings() + }) + codec.DefaultRegistry.Register("Projects$OneTimeConversionMarker", func() element.Element { + o := initOneTimeConversionMarker() + o.SetTypeName("Projects$OneTimeConversionMarker") + return o + }) + codec.DefaultRegistry.Register("Projects$OneTimeConversion", func() element.Element { + return initOneTimeConversionMarker() + }) + codec.DefaultRegistry.Register("Projects$Project", func() element.Element { + return initProject() + }) + codec.DefaultRegistry.Register("Projects$ProjectConversion", func() element.Element { + return initProjectConversion() + }) +} diff --git a/modelsdk/gen/projects/version.go b/modelsdk/gen/projects/version.go new file mode 100644 index 00000000..804e78a9 --- /dev/null +++ b/modelsdk/gen/projects/version.go @@ -0,0 +1,62 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package projects + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Projects$Document": { + Properties: map[string]version.PropertyVersionInfo{ + "documentation": {Public: true}, + "excluded": {Public: true}, + "exportLevel": {Introduced: "9.3.0"}, + "name": {Public: true}, + }, + }, + "Projects$JarDependency": { + Properties: map[string]version.PropertyVersionInfo{ + "exclusions": {Introduced: "10.12.0"}, + }, + }, + "Projects$Module": { + Properties: map[string]version.PropertyVersionInfo{ + "appStorePackageId": {Introduced: "8.13.0", Deleted: "11.0.0"}, + "appStorePackageIdString": {Introduced: "11.0.0"}, + "domainModel": {Required: true}, + "exportLevel": {Introduced: "9.3.0", Deleted: "9.8.0"}, + "isReusableComponent": {Introduced: "8.5.0", Deleted: "9.1.0"}, + "isThemeModule": {Introduced: "9.3.0"}, + "moduleSecurity": {Required: true}, + "moduleSettings": {Introduced: "9.8.0", Required: true}, + }, + }, + "Projects$ModuleImpl": { + Properties: map[string]version.PropertyVersionInfo{ + "appStorePackageId": {Introduced: "8.13.0", Deleted: "11.0.0"}, + "appStorePackageIdString": {Introduced: "11.0.0"}, + "domainModel": {Required: true}, + "exportLevel": {Introduced: "9.3.0", Deleted: "9.8.0"}, + "isReusableComponent": {Introduced: "8.5.0", Deleted: "9.1.0"}, + "isThemeModule": {Introduced: "9.3.0"}, + "moduleSecurity": {Required: true}, + "moduleSettings": {Introduced: "9.8.0", Required: true}, + }, + }, + "Projects$ModuleSettings": { + Properties: map[string]version.PropertyVersionInfo{ + "basedOnVersion": {Introduced: "10.0.0"}, + "extensionName": {Introduced: "10.10.0"}, + "jarDependencies": {Introduced: "10.0.0"}, + "protectedModuleType": {Introduced: "9.12.0"}, + "solutionIdentifier": {Introduced: "10.0.0"}, + }, + }, + "Projects$Project": { + Properties: map[string]version.PropertyVersionInfo{ + "projectConversion": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/queues/enums.go b/modelsdk/gen/queues/enums.go new file mode 100644 index 00000000..c600ff60 --- /dev/null +++ b/modelsdk/gen/queues/enums.go @@ -0,0 +1,14 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package queues + +// QueueRetryIntervalType enumerates the possible values for the QueueRetryIntervalType type. +type QueueRetryIntervalType = string + +const ( + QueueRetryIntervalTypeSeconds QueueRetryIntervalType = "Seconds" + QueueRetryIntervalTypeMinutes QueueRetryIntervalType = "Minutes" + QueueRetryIntervalTypeHours QueueRetryIntervalType = "Hours" +) diff --git a/modelsdk/gen/queues/refs.go b/modelsdk/gen/queues/refs.go new file mode 100644 index 00000000..701c33ac --- /dev/null +++ b/modelsdk/gen/queues/refs.go @@ -0,0 +1,13 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package queues + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Queues$QueueSettings", []codec.RefMeta{ + {Prop: "Queue", Kind: codec.RefByName, Target: "Queues$Queue"}, + }) +} diff --git a/modelsdk/gen/queues/types.go b/modelsdk/gen/queues/types.go new file mode 100644 index 00000000..231740d3 --- /dev/null +++ b/modelsdk/gen/queues/types.go @@ -0,0 +1,479 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package queues + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// QueueConfig +// ──────────────────────────────────────────────────────── + +type QueueConfig struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueueConfig) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BasicQueueConfig +// ──────────────────────────────────────────────────────── + +type BasicQueueConfig struct { + element.Base + parallelismExpression *property.Primitive[string] + parallelism *property.Primitive[int32] + clusterWide *property.Primitive[bool] +} + +// ParallelismExpression returns the value of the parallelismExpression property. +func (o *BasicQueueConfig) ParallelismExpression() string { + return o.parallelismExpression.Get() +} + +// SetParallelismExpression sets the value of the parallelismExpression property. +func (o *BasicQueueConfig) SetParallelismExpression(v string) { + o.parallelismExpression.Set(v) +} + +// Parallelism returns the value of the parallelism property. +func (o *BasicQueueConfig) Parallelism() int32 { + return o.parallelism.Get() +} + +// SetParallelism sets the value of the parallelism property. +func (o *BasicQueueConfig) SetParallelism(v int32) { + o.parallelism.Set(v) +} + +// ClusterWide returns the value of the clusterWide property. +func (o *BasicQueueConfig) ClusterWide() bool { + return o.clusterWide.Get() +} + +// SetClusterWide sets the value of the clusterWide property. +func (o *BasicQueueConfig) SetClusterWide(v bool) { + o.clusterWide.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicQueueConfig) InitFromRaw(raw bson.Raw) { + o.parallelismExpression.Init(raw) + o.parallelism.Init(raw) + o.clusterWide.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Queue +// ──────────────────────────────────────────────────────── + +type Queue struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + config *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *Queue) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Queue) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Queue) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Queue) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Queue) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Queue) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Queue) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Queue) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Config returns the value of the config property. +func (o *Queue) Config() element.Element { + return o.config.Get() +} + +// SetConfig sets the value of the config property. +func (o *Queue) SetConfig(v element.Element) { + o.config.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Queue) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Config"); err == nil { + o.config.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// QueueRetry +// ──────────────────────────────────────────────────────── + +type QueueRetry struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueueRetry) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// QueueExponentialRetry +// ──────────────────────────────────────────────────────── + +type QueueExponentialRetry struct { + element.Base + retries *property.Primitive[int32] + initialInterval *property.Primitive[int32] + maximumInterval *property.Primitive[int32] + intervalType *property.Enum[string] +} + +// Retries returns the value of the retries property. +func (o *QueueExponentialRetry) Retries() int32 { + return o.retries.Get() +} + +// SetRetries sets the value of the retries property. +func (o *QueueExponentialRetry) SetRetries(v int32) { + o.retries.Set(v) +} + +// InitialInterval returns the value of the initialInterval property. +func (o *QueueExponentialRetry) InitialInterval() int32 { + return o.initialInterval.Get() +} + +// SetInitialInterval sets the value of the initialInterval property. +func (o *QueueExponentialRetry) SetInitialInterval(v int32) { + o.initialInterval.Set(v) +} + +// MaximumInterval returns the value of the maximumInterval property. +func (o *QueueExponentialRetry) MaximumInterval() int32 { + return o.maximumInterval.Get() +} + +// SetMaximumInterval sets the value of the maximumInterval property. +func (o *QueueExponentialRetry) SetMaximumInterval(v int32) { + o.maximumInterval.Set(v) +} + +// IntervalType returns the value of the intervalType property. +func (o *QueueExponentialRetry) IntervalType() string { + return o.intervalType.Get() +} + +// SetIntervalType sets the value of the intervalType property. +func (o *QueueExponentialRetry) SetIntervalType(v string) { + o.intervalType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueueExponentialRetry) InitFromRaw(raw bson.Raw) { + o.retries.Init(raw) + o.initialInterval.Init(raw) + o.maximumInterval.Init(raw) + if val, err := raw.LookupErr("IntervalType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.intervalType.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// QueueFixedRetry +// ──────────────────────────────────────────────────────── + +type QueueFixedRetry struct { + element.Base + retries *property.Primitive[int32] + interval *property.Primitive[int32] + intervalType *property.Enum[string] +} + +// Retries returns the value of the retries property. +func (o *QueueFixedRetry) Retries() int32 { + return o.retries.Get() +} + +// SetRetries sets the value of the retries property. +func (o *QueueFixedRetry) SetRetries(v int32) { + o.retries.Set(v) +} + +// Interval returns the value of the interval property. +func (o *QueueFixedRetry) Interval() int32 { + return o.interval.Get() +} + +// SetInterval sets the value of the interval property. +func (o *QueueFixedRetry) SetInterval(v int32) { + o.interval.Set(v) +} + +// IntervalType returns the value of the intervalType property. +func (o *QueueFixedRetry) IntervalType() string { + return o.intervalType.Get() +} + +// SetIntervalType sets the value of the intervalType property. +func (o *QueueFixedRetry) SetIntervalType(v string) { + o.intervalType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueueFixedRetry) InitFromRaw(raw bson.Raw) { + o.retries.Init(raw) + o.interval.Init(raw) + if val, err := raw.LookupErr("IntervalType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.intervalType.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// QueueSettings +// ──────────────────────────────────────────────────────── + +type QueueSettings struct { + element.Base + queue *property.ByNameRef[element.Element] + retry *property.Part[element.Element] +} + +// QueueQualifiedName returns the value of the queue property. +func (o *QueueSettings) QueueQualifiedName() string { + return o.queue.QualifiedName() +} + +// SetQueueQualifiedName sets the value of the queue property. +func (o *QueueSettings) SetQueueQualifiedName(v string) { + o.queue.SetQualifiedName(v) +} + +// Retry returns the value of the retry property. +func (o *QueueSettings) Retry() element.Element { + return o.retry.Get() +} + +// SetRetry sets the value of the retry property. +func (o *QueueSettings) SetRetry(v element.Element) { + o.retry.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueueSettings) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Queue"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.queue.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Retry"); err == nil { + o.retry.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initBasicQueueConfig creates a BasicQueueConfig with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicQueueConfig() *BasicQueueConfig { + o := &BasicQueueConfig{} + o.SetTypeName("Queues$BasicQueueConfig") + o.parallelismExpression = property.NewPrimitive[string]("ParallelismExpression", property.DecodeString) + o.parallelismExpression.Bind(&o.Base, 0) + o.parallelism = property.NewPrimitive[int32]("Parallelism", property.DecodeInt32) + o.parallelism.Bind(&o.Base, 1) + o.clusterWide = property.NewPrimitive[bool]("ClusterWide", property.DecodeBool) + o.clusterWide.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.parallelismExpression, o.parallelism, o.clusterWide}) + return o +} + +// NewBasicQueueConfig creates a new BasicQueueConfig for user code. Marked dirty (bit 63 = new element). +func NewBasicQueueConfig() *BasicQueueConfig { + o := initBasicQueueConfig() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initQueue creates a Queue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initQueue() *Queue { + o := &Queue{} + o.SetTypeName("Queues$Queue") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.config = property.NewPart[element.Element]("Config") + o.config.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.config}) + return o +} + +// NewQueue creates a new Queue for user code. Marked dirty (bit 63 = new element). +func NewQueue() *Queue { + o := initQueue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initQueueExponentialRetry creates a QueueExponentialRetry with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initQueueExponentialRetry() *QueueExponentialRetry { + o := &QueueExponentialRetry{} + o.SetTypeName("Queues$QueueExponentialRetry") + o.retries = property.NewPrimitive[int32]("Retries", property.DecodeInt32) + o.retries.Bind(&o.Base, 0) + o.initialInterval = property.NewPrimitive[int32]("InitialInterval", property.DecodeInt32) + o.initialInterval.Bind(&o.Base, 1) + o.maximumInterval = property.NewPrimitive[int32]("MaximumInterval", property.DecodeInt32) + o.maximumInterval.Bind(&o.Base, 2) + o.intervalType = property.NewEnum[string]("IntervalType") + o.intervalType.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.retries, o.initialInterval, o.maximumInterval, o.intervalType}) + return o +} + +// NewQueueExponentialRetry creates a new QueueExponentialRetry for user code. Marked dirty (bit 63 = new element). +func NewQueueExponentialRetry() *QueueExponentialRetry { + o := initQueueExponentialRetry() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initQueueFixedRetry creates a QueueFixedRetry with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initQueueFixedRetry() *QueueFixedRetry { + o := &QueueFixedRetry{} + o.SetTypeName("Queues$QueueFixedRetry") + o.retries = property.NewPrimitive[int32]("Retries", property.DecodeInt32) + o.retries.Bind(&o.Base, 0) + o.interval = property.NewPrimitive[int32]("Interval", property.DecodeInt32) + o.interval.Bind(&o.Base, 1) + o.intervalType = property.NewEnum[string]("IntervalType") + o.intervalType.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.retries, o.interval, o.intervalType}) + return o +} + +// NewQueueFixedRetry creates a new QueueFixedRetry for user code. Marked dirty (bit 63 = new element). +func NewQueueFixedRetry() *QueueFixedRetry { + o := initQueueFixedRetry() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initQueueSettings creates a QueueSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initQueueSettings() *QueueSettings { + o := &QueueSettings{} + o.SetTypeName("Queues$QueueSettings") + o.queue = property.NewByNameRef[element.Element]("Queue", "Queues$Queue") + o.queue.Bind(&o.Base, 0) + o.retry = property.NewPart[element.Element]("Retry") + o.retry.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.queue, o.retry}) + return o +} + +// NewQueueSettings creates a new QueueSettings for user code. Marked dirty (bit 63 = new element). +func NewQueueSettings() *QueueSettings { + o := initQueueSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Queues$BasicQueueConfig", func() element.Element { + return initBasicQueueConfig() + }) + codec.DefaultRegistry.Register("Queues$Queue", func() element.Element { + return initQueue() + }) + codec.DefaultRegistry.Register("Queues$QueueExponentialRetry", func() element.Element { + return initQueueExponentialRetry() + }) + codec.DefaultRegistry.Register("Queues$QueueFixedRetry", func() element.Element { + return initQueueFixedRetry() + }) + codec.DefaultRegistry.Register("Queues$QueueSettings", func() element.Element { + return initQueueSettings() + }) +} diff --git a/modelsdk/gen/queues/version.go b/modelsdk/gen/queues/version.go new file mode 100644 index 00000000..d951a2a1 --- /dev/null +++ b/modelsdk/gen/queues/version.go @@ -0,0 +1,23 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package queues + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Queues$BasicQueueConfig": { + Properties: map[string]version.PropertyVersionInfo{ + "clusterWide": {Introduced: "9.13.0"}, + "parallelism": {Introduced: "8.16.0", Deleted: "9.12.0"}, + "parallelismExpression": {Introduced: "9.12.0"}, + }, + }, + "Queues$Queue": { + Properties: map[string]version.PropertyVersionInfo{ + "config": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/regularexpressions/enums.go b/modelsdk/gen/regularexpressions/enums.go new file mode 100644 index 00000000..df3d8738 --- /dev/null +++ b/modelsdk/gen/regularexpressions/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package regularexpressions diff --git a/modelsdk/gen/regularexpressions/refs.go b/modelsdk/gen/regularexpressions/refs.go new file mode 100644 index 00000000..df3d8738 --- /dev/null +++ b/modelsdk/gen/regularexpressions/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package regularexpressions diff --git a/modelsdk/gen/regularexpressions/types.go b/modelsdk/gen/regularexpressions/types.go new file mode 100644 index 00000000..12ae333a --- /dev/null +++ b/modelsdk/gen/regularexpressions/types.go @@ -0,0 +1,135 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package regularexpressions + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// RegularExpression +// ──────────────────────────────────────────────────────── + +type RegularExpression struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + regEx *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *RegularExpression) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RegularExpression) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *RegularExpression) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *RegularExpression) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *RegularExpression) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *RegularExpression) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *RegularExpression) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *RegularExpression) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// RegEx returns the value of the regEx property. +func (o *RegularExpression) RegEx() string { + return o.regEx.Get() +} + +// SetRegEx sets the value of the regEx property. +func (o *RegularExpression) SetRegEx(v string) { + o.regEx.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RegularExpression) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.regEx.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initRegularExpression creates a RegularExpression with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRegularExpression() *RegularExpression { + o := &RegularExpression{} + o.SetTypeName("RegularExpressions$RegularExpression") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.regEx = property.NewPrimitive[string]("RegEx", property.DecodeString) + o.regEx.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.regEx}) + return o +} + +// NewRegularExpression creates a new RegularExpression for user code. Marked dirty (bit 63 = new element). +func NewRegularExpression() *RegularExpression { + o := initRegularExpression() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("RegularExpressions$RegularExpression", func() element.Element { + return initRegularExpression() + }) +} diff --git a/modelsdk/gen/regularexpressions/version.go b/modelsdk/gen/regularexpressions/version.go new file mode 100644 index 00000000..5ceab5f7 --- /dev/null +++ b/modelsdk/gen/regularexpressions/version.go @@ -0,0 +1,10 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package regularexpressions + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{} diff --git a/modelsdk/gen/reports/enums.go b/modelsdk/gen/reports/enums.go new file mode 100644 index 00000000..c0f1744e --- /dev/null +++ b/modelsdk/gen/reports/enums.go @@ -0,0 +1,60 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package reports + +// AggregateFunctionEnum enumerates the possible values for the AggregateFunctionEnum type. +type AggregateFunctionEnum = string + +const ( + AggregateFunctionEnumSum AggregateFunctionEnum = "Sum" + AggregateFunctionEnumAverage AggregateFunctionEnum = "Average" + AggregateFunctionEnumCount AggregateFunctionEnum = "Count" + AggregateFunctionEnumMinimum AggregateFunctionEnum = "Minimum" + AggregateFunctionEnumMaximum AggregateFunctionEnum = "Maximum" +) + +// AspectRatio enumerates the possible values for the AspectRatio type. +type AspectRatio = string + +const ( + AspectRatioSixteenToNine AspectRatio = "SixteenToNine" + AspectRatioThreeToTwo AspectRatio = "ThreeToTwo" + AspectRatioFourToThree AspectRatio = "FourToThree" + AspectRatioOneToOne AspectRatio = "OneToOne" + AspectRatioThreeToFour AspectRatio = "ThreeToFour" + AspectRatioTwoToThree AspectRatio = "TwoToThree" + AspectRatioNineToSixteen AspectRatio = "NineToSixteen" +) + +// ChartType enumerates the possible values for the ChartType type. +type ChartType = string + +const ( + ChartTypeVerticalBars ChartType = "VerticalBars" + ChartTypeVerticalBars3D ChartType = "VerticalBars3D" + ChartTypeHorizontalBars ChartType = "HorizontalBars" + ChartTypeLines ChartType = "Lines" + ChartTypeArea ChartType = "Area" +) + +// ColumnFormat enumerates the possible values for the ColumnFormat type. +type ColumnFormat = string + +const ( + ColumnFormatDefault ColumnFormat = "Default" + ColumnFormatMonthName ColumnFormat = "MonthName" + ColumnFormatWeekdayName ColumnFormat = "WeekdayName" +) + +// DateRangeFieldEnum enumerates the possible values for the DateRangeFieldEnum type. +type DateRangeFieldEnum = string + +const ( + DateRangeFieldEnumYear DateRangeFieldEnum = "Year" + DateRangeFieldEnumMonth DateRangeFieldEnum = "Month" + DateRangeFieldEnumWeek DateRangeFieldEnum = "Week" + DateRangeFieldEnumPeriod DateRangeFieldEnum = "Period" + DateRangeFieldEnumQuarter DateRangeFieldEnum = "Quarter" +) diff --git a/modelsdk/gen/reports/refs.go b/modelsdk/gen/reports/refs.go new file mode 100644 index 00000000..a1c20c3f --- /dev/null +++ b/modelsdk/gen/reports/refs.go @@ -0,0 +1,32 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package reports + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Reports$ReportWidget", []codec.RefMeta{ + {Prop: "DataSet", Kind: codec.RefByName, Target: "DataSets$DataSet"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Reports$BasicReport", []codec.RefMeta{ + {Prop: "DataSet", Kind: codec.RefByName, Target: "DataSets$DataSet"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Reports$ReportChart", []codec.RefMeta{ + {Prop: "DataSet", Kind: codec.RefByName, Target: "DataSets$DataSet"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Reports$ReportParameter", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "DataSets$DataSetParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Reports$ReportDateRangeSelector", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "DataSets$DataSetParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Reports$ReportDropDown", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "DataSets$DataSetParameter"}, + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Reports$ReportZoomInfo", []codec.RefMeta{ + {Prop: "TargetPage", Kind: codec.RefByName, Target: "Forms$Page"}, + }) +} diff --git a/modelsdk/gen/reports/types.go b/modelsdk/gen/reports/types.go new file mode 100644 index 00000000..96d4df36 --- /dev/null +++ b/modelsdk/gen/reports/types.go @@ -0,0 +1,1929 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package reports + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// ReportWidget +// ──────────────────────────────────────────────────────── + +type ReportWidget struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + dataSet *property.ByNameRef[element.Element] + generateOnLoad *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *ReportWidget) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ReportWidget) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ReportWidget) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ReportWidget) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ReportWidget) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ReportWidget) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ReportWidget) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ReportWidget) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ReportWidget) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ReportWidget) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// DataSetQualifiedName returns the value of the dataSet property. +func (o *ReportWidget) DataSetQualifiedName() string { + return o.dataSet.QualifiedName() +} + +// SetDataSetQualifiedName sets the value of the dataSet property. +func (o *ReportWidget) SetDataSetQualifiedName(v string) { + o.dataSet.SetQualifiedName(v) +} + +// GenerateOnLoad returns the value of the generateOnLoad property. +func (o *ReportWidget) GenerateOnLoad() bool { + return o.generateOnLoad.Get() +} + +// SetGenerateOnLoad sets the value of the generateOnLoad property. +func (o *ReportWidget) SetGenerateOnLoad(v bool) { + o.generateOnLoad.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportWidget) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if val, err := raw.LookupErr("DataSet"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.dataSet.SetFromDecode(s) + } + } + o.generateOnLoad.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// BasicReport +// ──────────────────────────────────────────────────────── + +type BasicReport struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + dataSet *property.ByNameRef[element.Element] + generateOnLoad *property.Primitive[bool] + columns *property.PartList[element.Element] + aggregates *property.PartList[element.Element] + showExportButton *property.Primitive[bool] + zoomInfo *property.Part[element.Element] + isPagingEnabled *property.Primitive[bool] + pageSize *property.Primitive[int32] +} + +// Name returns the value of the name property. +func (o *BasicReport) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *BasicReport) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *BasicReport) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *BasicReport) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *BasicReport) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *BasicReport) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *BasicReport) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *BasicReport) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *BasicReport) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *BasicReport) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// DataSetQualifiedName returns the value of the dataSet property. +func (o *BasicReport) DataSetQualifiedName() string { + return o.dataSet.QualifiedName() +} + +// SetDataSetQualifiedName sets the value of the dataSet property. +func (o *BasicReport) SetDataSetQualifiedName(v string) { + o.dataSet.SetQualifiedName(v) +} + +// GenerateOnLoad returns the value of the generateOnLoad property. +func (o *BasicReport) GenerateOnLoad() bool { + return o.generateOnLoad.Get() +} + +// SetGenerateOnLoad sets the value of the generateOnLoad property. +func (o *BasicReport) SetGenerateOnLoad(v bool) { + o.generateOnLoad.Set(v) +} + +// ColumnsItems returns the value of the columns property. +func (o *BasicReport) ColumnsItems() []element.Element { + return o.columns.Items() +} + +// AddColumns appends a child element to the columns list. +func (o *BasicReport) AddColumns(v element.Element) { + o.columns.Append(v) +} + +// RemoveColumns removes the element at the given index from the columns list. +func (o *BasicReport) RemoveColumns(index int) { + o.columns.Remove(index) +} + +// AggregatesItems returns the value of the aggregates property. +func (o *BasicReport) AggregatesItems() []element.Element { + return o.aggregates.Items() +} + +// AddAggregates appends a child element to the aggregates list. +func (o *BasicReport) AddAggregates(v element.Element) { + o.aggregates.Append(v) +} + +// RemoveAggregates removes the element at the given index from the aggregates list. +func (o *BasicReport) RemoveAggregates(index int) { + o.aggregates.Remove(index) +} + +// ShowExportButton returns the value of the showExportButton property. +func (o *BasicReport) ShowExportButton() bool { + return o.showExportButton.Get() +} + +// SetShowExportButton sets the value of the showExportButton property. +func (o *BasicReport) SetShowExportButton(v bool) { + o.showExportButton.Set(v) +} + +// ZoomInfo returns the value of the zoomInfo property. +func (o *BasicReport) ZoomInfo() element.Element { + return o.zoomInfo.Get() +} + +// SetZoomInfo sets the value of the zoomInfo property. +func (o *BasicReport) SetZoomInfo(v element.Element) { + o.zoomInfo.Set(v) +} + +// IsPagingEnabled returns the value of the isPagingEnabled property. +func (o *BasicReport) IsPagingEnabled() bool { + return o.isPagingEnabled.Get() +} + +// SetIsPagingEnabled sets the value of the isPagingEnabled property. +func (o *BasicReport) SetIsPagingEnabled(v bool) { + o.isPagingEnabled.Set(v) +} + +// PageSize returns the value of the pageSize property. +func (o *BasicReport) PageSize() int32 { + return o.pageSize.Get() +} + +// SetPageSize sets the value of the pageSize property. +func (o *BasicReport) SetPageSize(v int32) { + o.pageSize.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicReport) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if val, err := raw.LookupErr("DataSet"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.dataSet.SetFromDecode(s) + } + } + o.generateOnLoad.Init(raw) + if children, err := codec.DecodeChildren(raw, "Columns"); err == nil { + for _, child := range children { + o.columns.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Aggregates"); err == nil { + for _, child := range children { + o.aggregates.AppendFromDecode(child) + } + } + o.showExportButton.Init(raw) + if child, err := codec.DecodeChild(raw, "ZoomInfo"); err == nil { + o.zoomInfo.SetFromDecode(child) + } + o.isPagingEnabled.Init(raw) + o.pageSize.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// BasicReportAggregate +// ──────────────────────────────────────────────────────── + +type BasicReportAggregate struct { + element.Base + caption *property.Part[element.Element] + aggregateFunction *property.Enum[string] + applicablePerColumn *property.Primitive[string] +} + +// Caption returns the value of the caption property. +func (o *BasicReportAggregate) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *BasicReportAggregate) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// AggregateFunction returns the value of the aggregateFunction property. +func (o *BasicReportAggregate) AggregateFunction() string { + return o.aggregateFunction.Get() +} + +// SetAggregateFunction sets the value of the aggregateFunction property. +func (o *BasicReportAggregate) SetAggregateFunction(v string) { + o.aggregateFunction.Set(v) +} + +// ApplicablePerColumn returns the value of the applicablePerColumn property. +func (o *BasicReportAggregate) ApplicablePerColumn() string { + return o.applicablePerColumn.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicReportAggregate) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if val, err := raw.LookupErr("AggregateFunction"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.aggregateFunction.SetFromDecode(s) + } + } + o.applicablePerColumn.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// BasicReportColumn +// ──────────────────────────────────────────────────────── + +type BasicReportColumn struct { + element.Base + caption *property.Part[element.Element] + dataSetColumnName *property.Primitive[string] + width *property.Primitive[int32] + alignment *property.Enum[string] + format *property.Enum[string] +} + +// Caption returns the value of the caption property. +func (o *BasicReportColumn) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *BasicReportColumn) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// DataSetColumnName returns the value of the dataSetColumnName property. +func (o *BasicReportColumn) DataSetColumnName() string { + return o.dataSetColumnName.Get() +} + +// SetDataSetColumnName sets the value of the dataSetColumnName property. +func (o *BasicReportColumn) SetDataSetColumnName(v string) { + o.dataSetColumnName.Set(v) +} + +// Width returns the value of the width property. +func (o *BasicReportColumn) Width() int32 { + return o.width.Get() +} + +// SetWidth sets the value of the width property. +func (o *BasicReportColumn) SetWidth(v int32) { + o.width.Set(v) +} + +// Alignment returns the value of the alignment property. +func (o *BasicReportColumn) Alignment() string { + return o.alignment.Get() +} + +// SetAlignment sets the value of the alignment property. +func (o *BasicReportColumn) SetAlignment(v string) { + o.alignment.Set(v) +} + +// Format returns the value of the format property. +func (o *BasicReportColumn) Format() string { + return o.format.Get() +} + +// SetFormat sets the value of the format property. +func (o *BasicReportColumn) SetFormat(v string) { + o.format.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicReportColumn) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + o.dataSetColumnName.Init(raw) + o.width.Init(raw) + if val, err := raw.LookupErr("Alignment"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.alignment.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Format"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.format.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ReportButton +// ──────────────────────────────────────────────────────── + +type ReportButton struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + caption *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *ReportButton) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ReportButton) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ReportButton) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ReportButton) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ReportButton) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ReportButton) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ReportButton) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ReportButton) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ReportButton) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ReportButton) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ReportButton) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ReportButton) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportButton) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ReportChart +// ──────────────────────────────────────────────────────── + +type ReportChart struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + dataSet *property.ByNameRef[element.Element] + generateOnLoad *property.Primitive[bool] + propType *property.Enum[string] + seriess *property.PartList[element.Element] + xAxisCaption *property.Part[element.Element] + yAxisCaption *property.Part[element.Element] + xAxisColumn *property.Primitive[string] + xAxisFormat *property.Enum[string] + yAxisPrecision *property.Primitive[int32] + yAxisUseMinMax *property.Primitive[bool] + yAxisMinimum *property.Primitive[float64] + yAxisMaximum *property.Primitive[float64] + aspectRatio *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *ReportChart) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ReportChart) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ReportChart) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ReportChart) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ReportChart) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ReportChart) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ReportChart) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ReportChart) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ReportChart) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ReportChart) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// DataSetQualifiedName returns the value of the dataSet property. +func (o *ReportChart) DataSetQualifiedName() string { + return o.dataSet.QualifiedName() +} + +// SetDataSetQualifiedName sets the value of the dataSet property. +func (o *ReportChart) SetDataSetQualifiedName(v string) { + o.dataSet.SetQualifiedName(v) +} + +// GenerateOnLoad returns the value of the generateOnLoad property. +func (o *ReportChart) GenerateOnLoad() bool { + return o.generateOnLoad.Get() +} + +// SetGenerateOnLoad sets the value of the generateOnLoad property. +func (o *ReportChart) SetGenerateOnLoad(v bool) { + o.generateOnLoad.Set(v) +} + +// Type returns the value of the type property. +func (o *ReportChart) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *ReportChart) SetType(v string) { + o.propType.Set(v) +} + +// SeriessItems returns the value of the seriess property. +func (o *ReportChart) SeriessItems() []element.Element { + return o.seriess.Items() +} + +// AddSeriess appends a child element to the seriess list. +func (o *ReportChart) AddSeriess(v element.Element) { + o.seriess.Append(v) +} + +// RemoveSeriess removes the element at the given index from the seriess list. +func (o *ReportChart) RemoveSeriess(index int) { + o.seriess.Remove(index) +} + +// XAxisCaption returns the value of the xAxisCaption property. +func (o *ReportChart) XAxisCaption() element.Element { + return o.xAxisCaption.Get() +} + +// SetXAxisCaption sets the value of the xAxisCaption property. +func (o *ReportChart) SetXAxisCaption(v element.Element) { + o.xAxisCaption.Set(v) +} + +// YAxisCaption returns the value of the yAxisCaption property. +func (o *ReportChart) YAxisCaption() element.Element { + return o.yAxisCaption.Get() +} + +// SetYAxisCaption sets the value of the yAxisCaption property. +func (o *ReportChart) SetYAxisCaption(v element.Element) { + o.yAxisCaption.Set(v) +} + +// XAxisColumn returns the value of the xAxisColumn property. +func (o *ReportChart) XAxisColumn() string { + return o.xAxisColumn.Get() +} + +// SetXAxisColumn sets the value of the xAxisColumn property. +func (o *ReportChart) SetXAxisColumn(v string) { + o.xAxisColumn.Set(v) +} + +// XAxisFormat returns the value of the xAxisFormat property. +func (o *ReportChart) XAxisFormat() string { + return o.xAxisFormat.Get() +} + +// SetXAxisFormat sets the value of the xAxisFormat property. +func (o *ReportChart) SetXAxisFormat(v string) { + o.xAxisFormat.Set(v) +} + +// YAxisPrecision returns the value of the yAxisPrecision property. +func (o *ReportChart) YAxisPrecision() int32 { + return o.yAxisPrecision.Get() +} + +// SetYAxisPrecision sets the value of the yAxisPrecision property. +func (o *ReportChart) SetYAxisPrecision(v int32) { + o.yAxisPrecision.Set(v) +} + +// YAxisUseMinMax returns the value of the yAxisUseMinMax property. +func (o *ReportChart) YAxisUseMinMax() bool { + return o.yAxisUseMinMax.Get() +} + +// SetYAxisUseMinMax sets the value of the yAxisUseMinMax property. +func (o *ReportChart) SetYAxisUseMinMax(v bool) { + o.yAxisUseMinMax.Set(v) +} + +// YAxisMinimum returns the value of the yAxisMinimum property. +func (o *ReportChart) YAxisMinimum() float64 { + return o.yAxisMinimum.Get() +} + +// SetYAxisMinimum sets the value of the yAxisMinimum property. +func (o *ReportChart) SetYAxisMinimum(v float64) { + o.yAxisMinimum.Set(v) +} + +// YAxisMaximum returns the value of the yAxisMaximum property. +func (o *ReportChart) YAxisMaximum() float64 { + return o.yAxisMaximum.Get() +} + +// SetYAxisMaximum sets the value of the yAxisMaximum property. +func (o *ReportChart) SetYAxisMaximum(v float64) { + o.yAxisMaximum.Set(v) +} + +// AspectRatio returns the value of the aspectRatio property. +func (o *ReportChart) AspectRatio() string { + return o.aspectRatio.Get() +} + +// SetAspectRatio sets the value of the aspectRatio property. +func (o *ReportChart) SetAspectRatio(v string) { + o.aspectRatio.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportChart) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if val, err := raw.LookupErr("DataSet"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.dataSet.SetFromDecode(s) + } + } + o.generateOnLoad.Init(raw) + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Seriess"); err == nil { + for _, child := range children { + o.seriess.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "XAxisCaption"); err == nil { + o.xAxisCaption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "YAxisCaption"); err == nil { + o.yAxisCaption.SetFromDecode(child) + } + o.xAxisColumn.Init(raw) + if val, err := raw.LookupErr("XAxisFormat"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.xAxisFormat.SetFromDecode(s) + } + } + o.yAxisPrecision.Init(raw) + o.yAxisUseMinMax.Init(raw) + o.yAxisMinimum.Init(raw) + o.yAxisMaximum.Init(raw) + if val, err := raw.LookupErr("AspectRatio"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.aspectRatio.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ReportChartSeries +// ──────────────────────────────────────────────────────── + +type ReportChartSeries struct { + element.Base + caption *property.Part[element.Element] + dataSetColumn *property.Primitive[string] +} + +// Caption returns the value of the caption property. +func (o *ReportChartSeries) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ReportChartSeries) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// DataSetColumn returns the value of the dataSetColumn property. +func (o *ReportChartSeries) DataSetColumn() string { + return o.dataSetColumn.Get() +} + +// SetDataSetColumn sets the value of the dataSetColumn property. +func (o *ReportChartSeries) SetDataSetColumn(v string) { + o.dataSetColumn.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportChartSeries) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + o.dataSetColumn.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ReportDateRangeField +// ──────────────────────────────────────────────────────── + +type ReportDateRangeField struct { + element.Base + caption *property.Part[element.Element] + propType *property.Enum[string] +} + +// Caption returns the value of the caption property. +func (o *ReportDateRangeField) Caption() element.Element { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ReportDateRangeField) SetCaption(v element.Element) { + o.caption.Set(v) +} + +// Type returns the value of the type property. +func (o *ReportDateRangeField) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *ReportDateRangeField) SetType(v string) { + o.propType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportDateRangeField) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Caption"); err == nil { + o.caption.SetFromDecode(child) + } + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ReportParameter +// ──────────────────────────────────────────────────────── + +type ReportParameter struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + parameter *property.ByNameRef[element.Element] + parameterName *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *ReportParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ReportParameter) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ReportParameter) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ReportParameter) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ReportParameter) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ReportParameter) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ReportParameter) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ReportParameter) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ReportParameter) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ReportParameter) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *ReportParameter) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *ReportParameter) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// ParameterName returns the value of the parameterName property. +func (o *ReportParameter) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *ReportParameter) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parameter.SetFromDecode(s) + } + } + o.parameterName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ReportDateRangeSelector +// ──────────────────────────────────────────────────────── + +type ReportDateRangeSelector struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + parameter *property.ByNameRef[element.Element] + parameterName *property.Primitive[string] + fields *property.PartList[element.Element] + minYear *property.Primitive[int32] + maxYear *property.Primitive[int32] + fieldsPerRow *property.Primitive[int32] + showFromToRange *property.Primitive[bool] + fromCaption *property.Part[element.Element] + toCaption *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *ReportDateRangeSelector) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ReportDateRangeSelector) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ReportDateRangeSelector) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ReportDateRangeSelector) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ReportDateRangeSelector) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ReportDateRangeSelector) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ReportDateRangeSelector) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ReportDateRangeSelector) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ReportDateRangeSelector) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ReportDateRangeSelector) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *ReportDateRangeSelector) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *ReportDateRangeSelector) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// ParameterName returns the value of the parameterName property. +func (o *ReportDateRangeSelector) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *ReportDateRangeSelector) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// FieldsItems returns the value of the fields property. +func (o *ReportDateRangeSelector) FieldsItems() []element.Element { + return o.fields.Items() +} + +// AddFields appends a child element to the fields list. +func (o *ReportDateRangeSelector) AddFields(v element.Element) { + o.fields.Append(v) +} + +// RemoveFields removes the element at the given index from the fields list. +func (o *ReportDateRangeSelector) RemoveFields(index int) { + o.fields.Remove(index) +} + +// MinYear returns the value of the minYear property. +func (o *ReportDateRangeSelector) MinYear() int32 { + return o.minYear.Get() +} + +// SetMinYear sets the value of the minYear property. +func (o *ReportDateRangeSelector) SetMinYear(v int32) { + o.minYear.Set(v) +} + +// MaxYear returns the value of the maxYear property. +func (o *ReportDateRangeSelector) MaxYear() int32 { + return o.maxYear.Get() +} + +// SetMaxYear sets the value of the maxYear property. +func (o *ReportDateRangeSelector) SetMaxYear(v int32) { + o.maxYear.Set(v) +} + +// FieldsPerRow returns the value of the fieldsPerRow property. +func (o *ReportDateRangeSelector) FieldsPerRow() int32 { + return o.fieldsPerRow.Get() +} + +// SetFieldsPerRow sets the value of the fieldsPerRow property. +func (o *ReportDateRangeSelector) SetFieldsPerRow(v int32) { + o.fieldsPerRow.Set(v) +} + +// ShowFromToRange returns the value of the showFromToRange property. +func (o *ReportDateRangeSelector) ShowFromToRange() bool { + return o.showFromToRange.Get() +} + +// SetShowFromToRange sets the value of the showFromToRange property. +func (o *ReportDateRangeSelector) SetShowFromToRange(v bool) { + o.showFromToRange.Set(v) +} + +// FromCaption returns the value of the fromCaption property. +func (o *ReportDateRangeSelector) FromCaption() element.Element { + return o.fromCaption.Get() +} + +// SetFromCaption sets the value of the fromCaption property. +func (o *ReportDateRangeSelector) SetFromCaption(v element.Element) { + o.fromCaption.Set(v) +} + +// ToCaption returns the value of the toCaption property. +func (o *ReportDateRangeSelector) ToCaption() element.Element { + return o.toCaption.Get() +} + +// SetToCaption sets the value of the toCaption property. +func (o *ReportDateRangeSelector) SetToCaption(v element.Element) { + o.toCaption.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportDateRangeSelector) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parameter.SetFromDecode(s) + } + } + o.parameterName.Init(raw) + if children, err := codec.DecodeChildren(raw, "Fields"); err == nil { + for _, child := range children { + o.fields.AppendFromDecode(child) + } + } + o.minYear.Init(raw) + o.maxYear.Init(raw) + o.fieldsPerRow.Init(raw) + o.showFromToRange.Init(raw) + if child, err := codec.DecodeChild(raw, "FromCaption"); err == nil { + o.fromCaption.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ToCaption"); err == nil { + o.toCaption.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ReportDropDown +// ──────────────────────────────────────────────────────── + +type ReportDropDown struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + parameter *property.ByNameRef[element.Element] + parameterName *property.Primitive[string] + attribute *property.ByNameRef[element.Element] +} + +// Name returns the value of the name property. +func (o *ReportDropDown) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ReportDropDown) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ReportDropDown) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ReportDropDown) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ReportDropDown) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ReportDropDown) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ReportDropDown) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ReportDropDown) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ReportDropDown) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ReportDropDown) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *ReportDropDown) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *ReportDropDown) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// ParameterName returns the value of the parameterName property. +func (o *ReportDropDown) ParameterName() string { + return o.parameterName.Get() +} + +// SetParameterName sets the value of the parameterName property. +func (o *ReportDropDown) SetParameterName(v string) { + o.parameterName.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *ReportDropDown) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *ReportDropDown) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportDropDown) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parameter.SetFromDecode(s) + } + } + o.parameterName.Init(raw) + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ReportPane +// ──────────────────────────────────────────────────────── + +type ReportPane struct { + element.Base + name *property.Primitive[string] + class *property.Primitive[string] + style *property.Primitive[string] + appearance *property.Part[element.Element] + tabIndex *property.Primitive[int32] + parameterWidget *property.Part[element.Element] + reportWidget *property.Part[element.Element] + generateOnLoad *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *ReportPane) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ReportPane) SetName(v string) { + o.name.Set(v) +} + +// Class returns the value of the class property. +func (o *ReportPane) Class() string { + return o.class.Get() +} + +// SetClass sets the value of the class property. +func (o *ReportPane) SetClass(v string) { + o.class.Set(v) +} + +// Style returns the value of the style property. +func (o *ReportPane) Style() string { + return o.style.Get() +} + +// SetStyle sets the value of the style property. +func (o *ReportPane) SetStyle(v string) { + o.style.Set(v) +} + +// Appearance returns the value of the appearance property. +func (o *ReportPane) Appearance() element.Element { + return o.appearance.Get() +} + +// SetAppearance sets the value of the appearance property. +func (o *ReportPane) SetAppearance(v element.Element) { + o.appearance.Set(v) +} + +// TabIndex returns the value of the tabIndex property. +func (o *ReportPane) TabIndex() int32 { + return o.tabIndex.Get() +} + +// SetTabIndex sets the value of the tabIndex property. +func (o *ReportPane) SetTabIndex(v int32) { + o.tabIndex.Set(v) +} + +// ParameterWidget returns the value of the parameterWidget property. +func (o *ReportPane) ParameterWidget() element.Element { + return o.parameterWidget.Get() +} + +// SetParameterWidget sets the value of the parameterWidget property. +func (o *ReportPane) SetParameterWidget(v element.Element) { + o.parameterWidget.Set(v) +} + +// ReportWidget returns the value of the reportWidget property. +func (o *ReportPane) ReportWidget() element.Element { + return o.reportWidget.Get() +} + +// SetReportWidget sets the value of the reportWidget property. +func (o *ReportPane) SetReportWidget(v element.Element) { + o.reportWidget.Set(v) +} + +// GenerateOnLoad returns the value of the generateOnLoad property. +func (o *ReportPane) GenerateOnLoad() bool { + return o.generateOnLoad.Get() +} + +// SetGenerateOnLoad sets the value of the generateOnLoad property. +func (o *ReportPane) SetGenerateOnLoad(v bool) { + o.generateOnLoad.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportPane) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.class.Init(raw) + o.style.Init(raw) + if child, err := codec.DecodeChild(raw, "Appearance"); err == nil { + o.appearance.SetFromDecode(child) + } + o.tabIndex.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterWidget"); err == nil { + o.parameterWidget.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ReportWidget"); err == nil { + o.reportWidget.SetFromDecode(child) + } + o.generateOnLoad.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ReportZoomInfo +// ──────────────────────────────────────────────────────── + +type ReportZoomInfo struct { + element.Base + targetPage *property.ByNameRef[element.Element] + mappings *property.PartList[element.Element] +} + +// TargetPageQualifiedName returns the value of the targetPage property. +func (o *ReportZoomInfo) TargetPageQualifiedName() string { + return o.targetPage.QualifiedName() +} + +// SetTargetPageQualifiedName sets the value of the targetPage property. +func (o *ReportZoomInfo) SetTargetPageQualifiedName(v string) { + o.targetPage.SetQualifiedName(v) +} + +// MappingsItems returns the value of the mappings property. +func (o *ReportZoomInfo) MappingsItems() []element.Element { + return o.mappings.Items() +} + +// AddMappings appends a child element to the mappings list. +func (o *ReportZoomInfo) AddMappings(v element.Element) { + o.mappings.Append(v) +} + +// RemoveMappings removes the element at the given index from the mappings list. +func (o *ReportZoomInfo) RemoveMappings(index int) { + o.mappings.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportZoomInfo) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("TargetPage"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.targetPage.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Mappings"); err == nil { + for _, child := range children { + o.mappings.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ReportZoomMapping +// ──────────────────────────────────────────────────────── + +type ReportZoomMapping struct { + element.Base + targetParameterName *property.Primitive[string] + sourceReportColumnName *property.Primitive[string] +} + +// TargetParameterName returns the value of the targetParameterName property. +func (o *ReportZoomMapping) TargetParameterName() string { + return o.targetParameterName.Get() +} + +// SetTargetParameterName sets the value of the targetParameterName property. +func (o *ReportZoomMapping) SetTargetParameterName(v string) { + o.targetParameterName.Set(v) +} + +// SourceReportColumnName returns the value of the sourceReportColumnName property. +func (o *ReportZoomMapping) SourceReportColumnName() string { + return o.sourceReportColumnName.Get() +} + +// SetSourceReportColumnName sets the value of the sourceReportColumnName property. +func (o *ReportZoomMapping) SetSourceReportColumnName(v string) { + o.sourceReportColumnName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReportZoomMapping) InitFromRaw(raw bson.Raw) { + o.targetParameterName.Init(raw) + o.sourceReportColumnName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initBasicReport creates a BasicReport with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicReport() *BasicReport { + o := &BasicReport{} + o.SetTypeName("Reports$BasicReport") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.dataSet = property.NewByNameRef[element.Element]("DataSet", "DataSets$DataSet") + o.dataSet.Bind(&o.Base, 5) + o.generateOnLoad = property.NewPrimitive[bool]("GenerateOnLoad", property.DecodeBool) + o.generateOnLoad.Bind(&o.Base, 6) + o.columns = property.NewPartList[element.Element]("Columns") + o.columns.Bind(&o.Base, 7) + o.aggregates = property.NewPartList[element.Element]("Aggregates") + o.aggregates.Bind(&o.Base, 8) + o.showExportButton = property.NewPrimitive[bool]("ShowExportButton", property.DecodeBool) + o.showExportButton.Bind(&o.Base, 9) + o.zoomInfo = property.NewPart[element.Element]("ZoomInfo") + o.zoomInfo.Bind(&o.Base, 10) + o.isPagingEnabled = property.NewPrimitive[bool]("IsPagingEnabled", property.DecodeBool) + o.isPagingEnabled.Bind(&o.Base, 11) + o.pageSize = property.NewPrimitive[int32]("PageSize", property.DecodeInt32) + o.pageSize.Bind(&o.Base, 12) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.dataSet, o.generateOnLoad, o.columns, o.aggregates, o.showExportButton, o.zoomInfo, o.isPagingEnabled, o.pageSize}) + return o +} + +// NewBasicReport creates a new BasicReport for user code. Marked dirty (bit 63 = new element). +func NewBasicReport() *BasicReport { + o := initBasicReport() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBasicReportAggregate creates a BasicReportAggregate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicReportAggregate() *BasicReportAggregate { + o := &BasicReportAggregate{} + o.SetTypeName("Reports$BasicReportAggregate") + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 0) + o.aggregateFunction = property.NewEnum[string]("AggregateFunction") + o.aggregateFunction.Bind(&o.Base, 1) + o.applicablePerColumn = property.NewPrimitive[string]("ApplicablePerColumn", property.DecodeString) + o.applicablePerColumn.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.caption, o.aggregateFunction, o.applicablePerColumn}) + return o +} + +// NewBasicReportAggregate creates a new BasicReportAggregate for user code. Marked dirty (bit 63 = new element). +func NewBasicReportAggregate() *BasicReportAggregate { + o := initBasicReportAggregate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBasicReportColumn creates a BasicReportColumn with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicReportColumn() *BasicReportColumn { + o := &BasicReportColumn{} + o.SetTypeName("Reports$BasicReportColumn") + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 0) + o.dataSetColumnName = property.NewPrimitive[string]("DataSetColumnName", property.DecodeString) + o.dataSetColumnName.Bind(&o.Base, 1) + o.width = property.NewPrimitive[int32]("Width", property.DecodeInt32) + o.width.Bind(&o.Base, 2) + o.alignment = property.NewEnum[string]("Alignment") + o.alignment.Bind(&o.Base, 3) + o.format = property.NewEnum[string]("Format") + o.format.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.caption, o.dataSetColumnName, o.width, o.alignment, o.format}) + return o +} + +// NewBasicReportColumn creates a new BasicReportColumn for user code. Marked dirty (bit 63 = new element). +func NewBasicReportColumn() *BasicReportColumn { + o := initBasicReportColumn() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReportButton creates a ReportButton with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReportButton() *ReportButton { + o := &ReportButton{} + o.SetTypeName("Reports$ReportButton") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.caption}) + return o +} + +// NewReportButton creates a new ReportButton for user code. Marked dirty (bit 63 = new element). +func NewReportButton() *ReportButton { + o := initReportButton() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReportChart creates a ReportChart with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReportChart() *ReportChart { + o := &ReportChart{} + o.SetTypeName("Reports$ReportChart") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.dataSet = property.NewByNameRef[element.Element]("DataSet", "DataSets$DataSet") + o.dataSet.Bind(&o.Base, 5) + o.generateOnLoad = property.NewPrimitive[bool]("GenerateOnLoad", property.DecodeBool) + o.generateOnLoad.Bind(&o.Base, 6) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 7) + o.seriess = property.NewPartList[element.Element]("Seriess") + o.seriess.Bind(&o.Base, 8) + o.xAxisCaption = property.NewPart[element.Element]("XAxisCaption") + o.xAxisCaption.Bind(&o.Base, 9) + o.yAxisCaption = property.NewPart[element.Element]("YAxisCaption") + o.yAxisCaption.Bind(&o.Base, 10) + o.xAxisColumn = property.NewPrimitive[string]("XAxisColumn", property.DecodeString) + o.xAxisColumn.Bind(&o.Base, 11) + o.xAxisFormat = property.NewEnum[string]("XAxisFormat") + o.xAxisFormat.Bind(&o.Base, 12) + o.yAxisPrecision = property.NewPrimitive[int32]("YAxisPrecision", property.DecodeInt32) + o.yAxisPrecision.Bind(&o.Base, 13) + o.yAxisUseMinMax = property.NewPrimitive[bool]("YAxisUseMinMax", property.DecodeBool) + o.yAxisUseMinMax.Bind(&o.Base, 14) + o.yAxisMinimum = property.NewPrimitive[float64]("YAxisMinimum", property.DecodeFloat64) + o.yAxisMinimum.Bind(&o.Base, 15) + o.yAxisMaximum = property.NewPrimitive[float64]("YAxisMaximum", property.DecodeFloat64) + o.yAxisMaximum.Bind(&o.Base, 16) + o.aspectRatio = property.NewEnum[string]("AspectRatio") + o.aspectRatio.Bind(&o.Base, 17) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.dataSet, o.generateOnLoad, o.propType, o.seriess, o.xAxisCaption, o.yAxisCaption, o.xAxisColumn, o.xAxisFormat, o.yAxisPrecision, o.yAxisUseMinMax, o.yAxisMinimum, o.yAxisMaximum, o.aspectRatio}) + return o +} + +// NewReportChart creates a new ReportChart for user code. Marked dirty (bit 63 = new element). +func NewReportChart() *ReportChart { + o := initReportChart() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReportChartSeries creates a ReportChartSeries with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReportChartSeries() *ReportChartSeries { + o := &ReportChartSeries{} + o.SetTypeName("Reports$ReportChartSeries") + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 0) + o.dataSetColumn = property.NewPrimitive[string]("DataSetColumn", property.DecodeString) + o.dataSetColumn.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.caption, o.dataSetColumn}) + return o +} + +// NewReportChartSeries creates a new ReportChartSeries for user code. Marked dirty (bit 63 = new element). +func NewReportChartSeries() *ReportChartSeries { + o := initReportChartSeries() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReportDateRangeField creates a ReportDateRangeField with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReportDateRangeField() *ReportDateRangeField { + o := &ReportDateRangeField{} + o.SetTypeName("Reports$ReportDateRangeField") + o.caption = property.NewPart[element.Element]("Caption") + o.caption.Bind(&o.Base, 0) + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.caption, o.propType}) + return o +} + +// NewReportDateRangeField creates a new ReportDateRangeField for user code. Marked dirty (bit 63 = new element). +func NewReportDateRangeField() *ReportDateRangeField { + o := initReportDateRangeField() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReportDateRangeSelector creates a ReportDateRangeSelector with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReportDateRangeSelector() *ReportDateRangeSelector { + o := &ReportDateRangeSelector{} + o.SetTypeName("Reports$ReportDateRangeSelector") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.parameter = property.NewByNameRef[element.Element]("Parameter", "DataSets$DataSetParameter") + o.parameter.Bind(&o.Base, 5) + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 6) + o.fields = property.NewPartList[element.Element]("Fields") + o.fields.Bind(&o.Base, 7) + o.minYear = property.NewPrimitive[int32]("MinYear", property.DecodeInt32) + o.minYear.Bind(&o.Base, 8) + o.maxYear = property.NewPrimitive[int32]("MaxYear", property.DecodeInt32) + o.maxYear.Bind(&o.Base, 9) + o.fieldsPerRow = property.NewPrimitive[int32]("FieldsPerRow", property.DecodeInt32) + o.fieldsPerRow.Bind(&o.Base, 10) + o.showFromToRange = property.NewPrimitive[bool]("ShowFromToRange", property.DecodeBool) + o.showFromToRange.Bind(&o.Base, 11) + o.fromCaption = property.NewPart[element.Element]("FromCaption") + o.fromCaption.Bind(&o.Base, 12) + o.toCaption = property.NewPart[element.Element]("ToCaption") + o.toCaption.Bind(&o.Base, 13) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.parameter, o.parameterName, o.fields, o.minYear, o.maxYear, o.fieldsPerRow, o.showFromToRange, o.fromCaption, o.toCaption}) + return o +} + +// NewReportDateRangeSelector creates a new ReportDateRangeSelector for user code. Marked dirty (bit 63 = new element). +func NewReportDateRangeSelector() *ReportDateRangeSelector { + o := initReportDateRangeSelector() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReportDropDown creates a ReportDropDown with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReportDropDown() *ReportDropDown { + o := &ReportDropDown{} + o.SetTypeName("Reports$ReportDropDown") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.parameter = property.NewByNameRef[element.Element]("Parameter", "DataSets$DataSetParameter") + o.parameter.Bind(&o.Base, 5) + o.parameterName = property.NewPrimitive[string]("ParameterName", property.DecodeString) + o.parameterName.Bind(&o.Base, 6) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.parameter, o.parameterName, o.attribute}) + return o +} + +// NewReportDropDown creates a new ReportDropDown for user code. Marked dirty (bit 63 = new element). +func NewReportDropDown() *ReportDropDown { + o := initReportDropDown() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReportPane creates a ReportPane with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReportPane() *ReportPane { + o := &ReportPane{} + o.SetTypeName("Reports$ReportPane") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.class = property.NewPrimitive[string]("Class", property.DecodeString) + o.class.Bind(&o.Base, 1) + o.style = property.NewPrimitive[string]("Style", property.DecodeString) + o.style.Bind(&o.Base, 2) + o.appearance = property.NewPart[element.Element]("Appearance") + o.appearance.Bind(&o.Base, 3) + o.tabIndex = property.NewPrimitive[int32]("TabIndex", property.DecodeInt32) + o.tabIndex.Bind(&o.Base, 4) + o.parameterWidget = property.NewPart[element.Element]("ParameterWidget") + o.parameterWidget.Bind(&o.Base, 5) + o.reportWidget = property.NewPart[element.Element]("ReportWidget") + o.reportWidget.Bind(&o.Base, 6) + o.generateOnLoad = property.NewPrimitive[bool]("GenerateOnLoad", property.DecodeBool) + o.generateOnLoad.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.class, o.style, o.appearance, o.tabIndex, o.parameterWidget, o.reportWidget, o.generateOnLoad}) + return o +} + +// NewReportPane creates a new ReportPane for user code. Marked dirty (bit 63 = new element). +func NewReportPane() *ReportPane { + o := initReportPane() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReportZoomInfo creates a ReportZoomInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReportZoomInfo() *ReportZoomInfo { + o := &ReportZoomInfo{} + o.SetTypeName("Reports$ReportZoomInfo") + o.targetPage = property.NewByNameRef[element.Element]("TargetPage", "Forms$Page") + o.targetPage.Bind(&o.Base, 0) + o.mappings = property.NewPartList[element.Element]("Mappings") + o.mappings.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.targetPage, o.mappings}) + return o +} + +// NewReportZoomInfo creates a new ReportZoomInfo for user code. Marked dirty (bit 63 = new element). +func NewReportZoomInfo() *ReportZoomInfo { + o := initReportZoomInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReportZoomMapping creates a ReportZoomMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReportZoomMapping() *ReportZoomMapping { + o := &ReportZoomMapping{} + o.SetTypeName("Reports$ReportZoomMapping") + o.targetParameterName = property.NewPrimitive[string]("TargetParameterName", property.DecodeString) + o.targetParameterName.Bind(&o.Base, 0) + o.sourceReportColumnName = property.NewPrimitive[string]("SourceReportColumnName", property.DecodeString) + o.sourceReportColumnName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.targetParameterName, o.sourceReportColumnName}) + return o +} + +// NewReportZoomMapping creates a new ReportZoomMapping for user code. Marked dirty (bit 63 = new element). +func NewReportZoomMapping() *ReportZoomMapping { + o := initReportZoomMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Reports$BasicReport", func() element.Element { + return initBasicReport() + }) + codec.DefaultRegistry.Register("Reports$BasicReportAggregate", func() element.Element { + return initBasicReportAggregate() + }) + codec.DefaultRegistry.Register("Reports$BasicReportColumn", func() element.Element { + return initBasicReportColumn() + }) + codec.DefaultRegistry.Register("Reports$ReportButton", func() element.Element { + return initReportButton() + }) + codec.DefaultRegistry.Register("Reports$ReportChart", func() element.Element { + return initReportChart() + }) + codec.DefaultRegistry.Register("Reports$ReportChartSeries", func() element.Element { + return initReportChartSeries() + }) + codec.DefaultRegistry.Register("Reports$ReportDateRangeField", func() element.Element { + return initReportDateRangeField() + }) + codec.DefaultRegistry.Register("Reports$ReportDateRangeSelector", func() element.Element { + return initReportDateRangeSelector() + }) + codec.DefaultRegistry.Register("Reports$ReportDropDown", func() element.Element { + return initReportDropDown() + }) + codec.DefaultRegistry.Register("Reports$ReportPane", func() element.Element { + return initReportPane() + }) + codec.DefaultRegistry.Register("Reports$ReportZoomInfo", func() element.Element { + return initReportZoomInfo() + }) + codec.DefaultRegistry.Register("Reports$ReportZoomMapping", func() element.Element { + return initReportZoomMapping() + }) +} diff --git a/modelsdk/gen/reports/version.go b/modelsdk/gen/reports/version.go new file mode 100644 index 00000000..0588950d --- /dev/null +++ b/modelsdk/gen/reports/version.go @@ -0,0 +1,65 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package reports + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Reports$ReportWidget": { + Properties: map[string]version.PropertyVersionInfo{ + "generateOnLoad": {Introduced: "6.10.0"}, + }, + }, + "Reports$BasicReport": { + Properties: map[string]version.PropertyVersionInfo{ + "columns": {Required: true}, + }, + }, + "Reports$BasicReportAggregate": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + }, + }, + "Reports$BasicReportColumn": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + }, + }, + "Reports$ReportButton": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + }, + }, + "Reports$ReportChart": { + Properties: map[string]version.PropertyVersionInfo{ + "xAxisCaption": {Required: true}, + "yAxisCaption": {Required: true}, + }, + }, + "Reports$ReportChartSeries": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + }, + }, + "Reports$ReportDateRangeField": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Required: true}, + }, + }, + "Reports$ReportParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Introduced: "6.10.0"}, + "parameterName": {Deleted: "6.10.0"}, + }, + }, + "Reports$ReportDateRangeSelector": { + Properties: map[string]version.PropertyVersionInfo{ + "fromCaption": {Required: true}, + "minYear": {}, + "toCaption": {Required: true}, + }, + }, +} diff --git a/modelsdk/gen/rest/enums.go b/modelsdk/gen/rest/enums.go new file mode 100644 index 00000000..14125bac --- /dev/null +++ b/modelsdk/gen/rest/enums.go @@ -0,0 +1,53 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package rest + +// AssociationNavigability enumerates the possible values for the AssociationNavigability type. +type AssociationNavigability = string + +const ( + AssociationNavigabilityBothDirections AssociationNavigability = "BothDirections" + AssociationNavigabilityParentToChild AssociationNavigability = "ParentToChild" + AssociationNavigabilityChildToParent AssociationNavigability = "ChildToParent" +) + +// ODataVersion enumerates the possible values for the ODataVersion type. +type ODataVersion = string + +const ( + ODataVersionOData2 ODataVersion = "OData2" + ODataVersionOData3 ODataVersion = "OData3" + ODataVersionOData4 ODataVersion = "OData4" +) + +// PublishedODataVersion enumerates the possible values for the PublishedODataVersion type. +type PublishedODataVersion = string + +const ( + PublishedODataVersionOData4 PublishedODataVersion = "OData4" + PublishedODataVersionOData3 PublishedODataVersion = "OData3" +) + +// RestAuthenticationType enumerates the possible values for the RestAuthenticationType type. +type RestAuthenticationType = string + +const ( + RestAuthenticationTypeBasic RestAuthenticationType = "Basic" + RestAuthenticationTypeNone RestAuthenticationType = "None" + RestAuthenticationTypeSession RestAuthenticationType = "Session" + RestAuthenticationTypeMicroflow RestAuthenticationType = "Microflow" + RestAuthenticationTypeGuest RestAuthenticationType = "Guest" +) + +// RestOperationParameterType enumerates the possible values for the RestOperationParameterType type. +type RestOperationParameterType = string + +const ( + RestOperationParameterTypePath RestOperationParameterType = "Path" + RestOperationParameterTypeQuery RestOperationParameterType = "Query" + RestOperationParameterTypeBody RestOperationParameterType = "Body" + RestOperationParameterTypeHeader RestOperationParameterType = "Header" + RestOperationParameterTypeForm RestOperationParameterType = "Form" +) diff --git a/modelsdk/gen/rest/refs.go b/modelsdk/gen/rest/refs.go new file mode 100644 index 00000000..574dc279 --- /dev/null +++ b/modelsdk/gen/rest/refs.go @@ -0,0 +1,82 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package rest + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Rest$CallMicroflowToChange", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$CallMicroflowToRead", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$ConstantValue", []codec.RefMeta{ + {Prop: "Value", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$ConsumedODataService", []codec.RefMeta{ + {Prop: "ProxyHost", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "ProxyPort", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "ProxyUsername", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "ProxyPassword", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "HeadersMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "ConfigurationMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "ErrorHandlingMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$CorsConfiguration", []codec.RefMeta{ + {Prop: "AllowedOrigins", Kind: codec.RefByName, Target: "Constants$Constant"}, + {Prop: "MaxAge", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$ODataEntityTypeSource", []codec.RefMeta{ + {Prop: "SourceDocument", Kind: codec.RefByName, Target: "Rest$ConsumedODataService"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$ODataPrimitiveCollectionEntitySource", []codec.RefMeta{ + {Prop: "SourceDocument", Kind: codec.RefByName, Target: "Rest$ConsumedODataService"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$ODataRemoteEntitySource", []codec.RefMeta{ + {Prop: "SourceDocument", Kind: codec.RefByName, Target: "Rest$ConsumedODataService"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$ODataRemoteEnumerationSource", []codec.RefMeta{ + {Prop: "ConsumedODataService", Kind: codec.RefByName, Target: "Rest$ConsumedODataService"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$PublishedODataEnumeration", []codec.RefMeta{ + {Prop: "Enumeration", Kind: codec.RefByName, Target: "Enumerations$Enumeration"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$PublishedODataEnumerationValue", []codec.RefMeta{ + {Prop: "EnumerationValue", Kind: codec.RefByName, Target: "Enumerations$EnumerationValue"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$PublishedODataMicroflow", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$PublishedODataMicroflowParameter", []codec.RefMeta{ + {Prop: "MicroflowParameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$PublishedODataService", []codec.RefMeta{ + {Prop: "AllowedModuleRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + {Prop: "AuthenticationMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$PublishedRestResource", []codec.RefMeta{ + {Prop: "UpdateMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "QueryMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "CountMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$PublishedRestService", []codec.RefMeta{ + {Prop: "AuthenticationMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "AllowedRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$PublishedRestServiceOperation", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "ExportMapping", Kind: codec.RefByName, Target: "ExportMappings$ExportMapping"}, + {Prop: "ImportMapping", Kind: codec.RefByName, Target: "ImportMappings$ImportMapping"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$RestOperationParameter", []codec.RefMeta{ + {Prop: "MicroflowParameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Rest$PublishedRestOperation", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "ImportMapping", Kind: codec.RefByName, Target: "ImportMappings$ImportMapping"}, + {Prop: "ExportMapping", Kind: codec.RefByName, Target: "ExportMappings$ExportMapping"}, + }) +} diff --git a/modelsdk/gen/rest/types.go b/modelsdk/gen/rest/types.go new file mode 100644 index 00000000..0498014f --- /dev/null +++ b/modelsdk/gen/rest/types.go @@ -0,0 +1,6345 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package rest + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// AuthenticationScheme +// ──────────────────────────────────────────────────────── + +type AuthenticationScheme struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AuthenticationScheme) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BasicAuthenticationScheme +// ──────────────────────────────────────────────────────── + +type BasicAuthenticationScheme struct { + element.Base + username *property.Part[element.Element] + password *property.Part[element.Element] +} + +// Username returns the value of the username property. +func (o *BasicAuthenticationScheme) Username() element.Element { + return o.username.Get() +} + +// SetUsername sets the value of the username property. +func (o *BasicAuthenticationScheme) SetUsername(v element.Element) { + o.username.Set(v) +} + +// Password returns the value of the password property. +func (o *BasicAuthenticationScheme) Password() element.Element { + return o.password.Get() +} + +// SetPassword sets the value of the password property. +func (o *BasicAuthenticationScheme) SetPassword(v element.Element) { + o.password.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BasicAuthenticationScheme) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Username"); err == nil { + o.username.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Password"); err == nil { + o.password.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Body +// ──────────────────────────────────────────────────────── + +type Body struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Body) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ChangeMode +// ──────────────────────────────────────────────────────── + +type ChangeMode struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ChangeMode) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CallMicroflowToChange +// ──────────────────────────────────────────────────────── + +type CallMicroflowToChange struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *CallMicroflowToChange) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *CallMicroflowToChange) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CallMicroflowToChange) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ReadMode +// ──────────────────────────────────────────────────────── + +type ReadMode struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReadMode) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CallMicroflowToRead +// ──────────────────────────────────────────────────────── + +type CallMicroflowToRead struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *CallMicroflowToRead) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *CallMicroflowToRead) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CallMicroflowToRead) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ChangeNotSupported +// ──────────────────────────────────────────────────────── + +type ChangeNotSupported struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ChangeNotSupported) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ChangeSource +// ──────────────────────────────────────────────────────── + +type ChangeSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ChangeSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Value +// ──────────────────────────────────────────────────────── + +type Value struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Value) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ConstantValue +// ──────────────────────────────────────────────────────── + +type ConstantValue struct { + element.Base + value *property.ByNameRef[element.Element] +} + +// ValueQualifiedName returns the value of the value property. +func (o *ConstantValue) ValueQualifiedName() string { + return o.value.QualifiedName() +} + +// SetValueQualifiedName sets the value of the value property. +func (o *ConstantValue) SetValueQualifiedName(v string) { + o.value.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConstantValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Value"); err == nil { + if s, ok := val.StringValueOK(); ok { o.value.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ConsumedODataService +// ──────────────────────────────────────────────────────── + +type ConsumedODataService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + description *property.Primitive[string] + catalogUrl *property.Primitive[string] + icon *property.Primitive[string] + metadata *property.Primitive[string] + metadataUrl *property.Primitive[string] + serviceName *property.Primitive[string] + version *property.Primitive[string] + endpointId *property.Primitive[string] + minimumMxVersion *property.Primitive[string] + recommendedMxVersion *property.Primitive[string] + applicationId *property.Primitive[string] + environmentType *property.Enum[string] + metadataHash *property.Primitive[string] + validated *property.Primitive[bool] + validatedEntities *property.Primitive[string] + metadataReferences *property.PartList[element.Element] + proxyType *property.Enum[string] + proxyHost *property.ByNameRef[element.Element] + proxyPort *property.ByNameRef[element.Element] + proxyUsername *property.ByNameRef[element.Element] + proxyPassword *property.ByNameRef[element.Element] + httpConfiguration *property.Part[element.Element] + headersMicroflow *property.ByNameRef[element.Element] + configurationMicroflow *property.ByNameRef[element.Element] + timeoutModel *property.Part[element.Element] + timeoutExpression *property.Primitive[string] + oDataVersion *property.Enum[string] + versionApiMockResults *property.Primitive[string] + serviceId *property.Primitive[string] + lastUpdated *property.Primitive[string] + useQuerySegment *property.Primitive[bool] + errorHandlingMicroflow *property.ByNameRef[element.Element] + serviceUrl *property.Primitive[string] + httpUsername *property.Primitive[string] + httpPassword *property.Primitive[string] + useAuthentication *property.Primitive[bool] + clientCertificate *property.Primitive[string] + headers *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *ConsumedODataService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConsumedODataService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ConsumedODataService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ConsumedODataService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ConsumedODataService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ConsumedODataService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ConsumedODataService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ConsumedODataService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Description returns the value of the description property. +func (o *ConsumedODataService) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *ConsumedODataService) SetDescription(v string) { + o.description.Set(v) +} + +// CatalogUrl returns the value of the catalogUrl property. +func (o *ConsumedODataService) CatalogUrl() string { + return o.catalogUrl.Get() +} + +// SetCatalogUrl sets the value of the catalogUrl property. +func (o *ConsumedODataService) SetCatalogUrl(v string) { + o.catalogUrl.Set(v) +} + +// Icon returns the value of the icon property. +func (o *ConsumedODataService) Icon() string { + return o.icon.Get() +} + +// SetIcon sets the value of the icon property. +func (o *ConsumedODataService) SetIcon(v string) { + o.icon.Set(v) +} + +// Metadata returns the value of the metadata property. +func (o *ConsumedODataService) Metadata() string { + return o.metadata.Get() +} + +// SetMetadata sets the value of the metadata property. +func (o *ConsumedODataService) SetMetadata(v string) { + o.metadata.Set(v) +} + +// MetadataUrl returns the value of the metadataUrl property. +func (o *ConsumedODataService) MetadataUrl() string { + return o.metadataUrl.Get() +} + +// SetMetadataUrl sets the value of the metadataUrl property. +func (o *ConsumedODataService) SetMetadataUrl(v string) { + o.metadataUrl.Set(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *ConsumedODataService) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *ConsumedODataService) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// Version returns the value of the version property. +func (o *ConsumedODataService) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *ConsumedODataService) SetVersion(v string) { + o.version.Set(v) +} + +// EndpointId returns the value of the endpointId property. +func (o *ConsumedODataService) EndpointId() string { + return o.endpointId.Get() +} + +// SetEndpointId sets the value of the endpointId property. +func (o *ConsumedODataService) SetEndpointId(v string) { + o.endpointId.Set(v) +} + +// MinimumMxVersion returns the value of the minimumMxVersion property. +func (o *ConsumedODataService) MinimumMxVersion() string { + return o.minimumMxVersion.Get() +} + +// SetMinimumMxVersion sets the value of the minimumMxVersion property. +func (o *ConsumedODataService) SetMinimumMxVersion(v string) { + o.minimumMxVersion.Set(v) +} + +// RecommendedMxVersion returns the value of the recommendedMxVersion property. +func (o *ConsumedODataService) RecommendedMxVersion() string { + return o.recommendedMxVersion.Get() +} + +// SetRecommendedMxVersion sets the value of the recommendedMxVersion property. +func (o *ConsumedODataService) SetRecommendedMxVersion(v string) { + o.recommendedMxVersion.Set(v) +} + +// ApplicationId returns the value of the applicationId property. +func (o *ConsumedODataService) ApplicationId() string { + return o.applicationId.Get() +} + +// SetApplicationId sets the value of the applicationId property. +func (o *ConsumedODataService) SetApplicationId(v string) { + o.applicationId.Set(v) +} + +// EnvironmentType returns the value of the environmentType property. +func (o *ConsumedODataService) EnvironmentType() string { + return o.environmentType.Get() +} + +// SetEnvironmentType sets the value of the environmentType property. +func (o *ConsumedODataService) SetEnvironmentType(v string) { + o.environmentType.Set(v) +} + +// MetadataHash returns the value of the metadataHash property. +func (o *ConsumedODataService) MetadataHash() string { + return o.metadataHash.Get() +} + +// SetMetadataHash sets the value of the metadataHash property. +func (o *ConsumedODataService) SetMetadataHash(v string) { + o.metadataHash.Set(v) +} + +// Validated returns the value of the validated property. +func (o *ConsumedODataService) Validated() bool { + return o.validated.Get() +} + +// SetValidated sets the value of the validated property. +func (o *ConsumedODataService) SetValidated(v bool) { + o.validated.Set(v) +} + +// ValidatedEntities returns the value of the validatedEntities property. +func (o *ConsumedODataService) ValidatedEntities() string { + return o.validatedEntities.Get() +} + +// MetadataReferencesItems returns the value of the metadataReferences property. +func (o *ConsumedODataService) MetadataReferencesItems() []element.Element { + return o.metadataReferences.Items() +} + +// AddMetadataReferences appends a child element to the metadataReferences list. +func (o *ConsumedODataService) AddMetadataReferences(v element.Element) { + o.metadataReferences.Append(v) +} + +// RemoveMetadataReferences removes the element at the given index from the metadataReferences list. +func (o *ConsumedODataService) RemoveMetadataReferences(index int) { + o.metadataReferences.Remove(index) +} + +// ProxyType returns the value of the proxyType property. +func (o *ConsumedODataService) ProxyType() string { + return o.proxyType.Get() +} + +// SetProxyType sets the value of the proxyType property. +func (o *ConsumedODataService) SetProxyType(v string) { + o.proxyType.Set(v) +} + +// ProxyHostQualifiedName returns the value of the proxyHost property. +func (o *ConsumedODataService) ProxyHostQualifiedName() string { + return o.proxyHost.QualifiedName() +} + +// SetProxyHostQualifiedName sets the value of the proxyHost property. +func (o *ConsumedODataService) SetProxyHostQualifiedName(v string) { + o.proxyHost.SetQualifiedName(v) +} + +// ProxyPortQualifiedName returns the value of the proxyPort property. +func (o *ConsumedODataService) ProxyPortQualifiedName() string { + return o.proxyPort.QualifiedName() +} + +// SetProxyPortQualifiedName sets the value of the proxyPort property. +func (o *ConsumedODataService) SetProxyPortQualifiedName(v string) { + o.proxyPort.SetQualifiedName(v) +} + +// ProxyUsernameQualifiedName returns the value of the proxyUsername property. +func (o *ConsumedODataService) ProxyUsernameQualifiedName() string { + return o.proxyUsername.QualifiedName() +} + +// SetProxyUsernameQualifiedName sets the value of the proxyUsername property. +func (o *ConsumedODataService) SetProxyUsernameQualifiedName(v string) { + o.proxyUsername.SetQualifiedName(v) +} + +// ProxyPasswordQualifiedName returns the value of the proxyPassword property. +func (o *ConsumedODataService) ProxyPasswordQualifiedName() string { + return o.proxyPassword.QualifiedName() +} + +// SetProxyPasswordQualifiedName sets the value of the proxyPassword property. +func (o *ConsumedODataService) SetProxyPasswordQualifiedName(v string) { + o.proxyPassword.SetQualifiedName(v) +} + +// HttpConfiguration returns the value of the httpConfiguration property. +func (o *ConsumedODataService) HttpConfiguration() element.Element { + return o.httpConfiguration.Get() +} + +// SetHttpConfiguration sets the value of the httpConfiguration property. +func (o *ConsumedODataService) SetHttpConfiguration(v element.Element) { + o.httpConfiguration.Set(v) +} + +// HeadersMicroflowQualifiedName returns the value of the headersMicroflow property. +func (o *ConsumedODataService) HeadersMicroflowQualifiedName() string { + return o.headersMicroflow.QualifiedName() +} + +// SetHeadersMicroflowQualifiedName sets the value of the headersMicroflow property. +func (o *ConsumedODataService) SetHeadersMicroflowQualifiedName(v string) { + o.headersMicroflow.SetQualifiedName(v) +} + +// ConfigurationMicroflowQualifiedName returns the value of the configurationMicroflow property. +func (o *ConsumedODataService) ConfigurationMicroflowQualifiedName() string { + return o.configurationMicroflow.QualifiedName() +} + +// SetConfigurationMicroflowQualifiedName sets the value of the configurationMicroflow property. +func (o *ConsumedODataService) SetConfigurationMicroflowQualifiedName(v string) { + o.configurationMicroflow.SetQualifiedName(v) +} + +// TimeoutModel returns the value of the timeoutModel property. +func (o *ConsumedODataService) TimeoutModel() element.Element { + return o.timeoutModel.Get() +} + +// SetTimeoutModel sets the value of the timeoutModel property. +func (o *ConsumedODataService) SetTimeoutModel(v element.Element) { + o.timeoutModel.Set(v) +} + +// TimeoutExpression returns the value of the timeoutExpression property. +func (o *ConsumedODataService) TimeoutExpression() string { + return o.timeoutExpression.Get() +} + +// SetTimeoutExpression sets the value of the timeoutExpression property. +func (o *ConsumedODataService) SetTimeoutExpression(v string) { + o.timeoutExpression.Set(v) +} + +// ODataVersion returns the value of the oDataVersion property. +func (o *ConsumedODataService) ODataVersion() string { + return o.oDataVersion.Get() +} + +// SetODataVersion sets the value of the oDataVersion property. +func (o *ConsumedODataService) SetODataVersion(v string) { + o.oDataVersion.Set(v) +} + +// VersionApiMockResults returns the value of the versionApiMockResults property. +func (o *ConsumedODataService) VersionApiMockResults() string { + return o.versionApiMockResults.Get() +} + +// SetVersionApiMockResults sets the value of the versionApiMockResults property. +func (o *ConsumedODataService) SetVersionApiMockResults(v string) { + o.versionApiMockResults.Set(v) +} + +// ServiceId returns the value of the serviceId property. +func (o *ConsumedODataService) ServiceId() string { + return o.serviceId.Get() +} + +// SetServiceId sets the value of the serviceId property. +func (o *ConsumedODataService) SetServiceId(v string) { + o.serviceId.Set(v) +} + +// LastUpdated returns the value of the lastUpdated property. +func (o *ConsumedODataService) LastUpdated() string { + return o.lastUpdated.Get() +} + +// SetLastUpdated sets the value of the lastUpdated property. +func (o *ConsumedODataService) SetLastUpdated(v string) { + o.lastUpdated.Set(v) +} + +// UseQuerySegment returns the value of the useQuerySegment property. +func (o *ConsumedODataService) UseQuerySegment() bool { + return o.useQuerySegment.Get() +} + +// SetUseQuerySegment sets the value of the useQuerySegment property. +func (o *ConsumedODataService) SetUseQuerySegment(v bool) { + o.useQuerySegment.Set(v) +} + +// ErrorHandlingMicroflowQualifiedName returns the value of the errorHandlingMicroflow property. +func (o *ConsumedODataService) ErrorHandlingMicroflowQualifiedName() string { + return o.errorHandlingMicroflow.QualifiedName() +} + +// SetErrorHandlingMicroflowQualifiedName sets the value of the errorHandlingMicroflow property. +func (o *ConsumedODataService) SetErrorHandlingMicroflowQualifiedName(v string) { + o.errorHandlingMicroflow.SetQualifiedName(v) +} + +// ServiceUrl returns the value of the serviceUrl property. +func (o *ConsumedODataService) ServiceUrl() string { + return o.serviceUrl.Get() +} + +// SetServiceUrl sets the value of the serviceUrl property. +func (o *ConsumedODataService) SetServiceUrl(v string) { + o.serviceUrl.Set(v) +} + +// HttpUsername returns the value of the httpUsername property. +func (o *ConsumedODataService) HttpUsername() string { + return o.httpUsername.Get() +} + +// SetHttpUsername sets the value of the httpUsername property. +func (o *ConsumedODataService) SetHttpUsername(v string) { + o.httpUsername.Set(v) +} + +// HttpPassword returns the value of the httpPassword property. +func (o *ConsumedODataService) HttpPassword() string { + return o.httpPassword.Get() +} + +// SetHttpPassword sets the value of the httpPassword property. +func (o *ConsumedODataService) SetHttpPassword(v string) { + o.httpPassword.Set(v) +} + +// UseAuthentication returns the value of the useAuthentication property. +func (o *ConsumedODataService) UseAuthentication() bool { + return o.useAuthentication.Get() +} + +// SetUseAuthentication sets the value of the useAuthentication property. +func (o *ConsumedODataService) SetUseAuthentication(v bool) { + o.useAuthentication.Set(v) +} + +// ClientCertificate returns the value of the clientCertificate property. +func (o *ConsumedODataService) ClientCertificate() string { + return o.clientCertificate.Get() +} + +// SetClientCertificate sets the value of the clientCertificate property. +func (o *ConsumedODataService) SetClientCertificate(v string) { + o.clientCertificate.Set(v) +} + +// HeadersItems returns the value of the headers property. +func (o *ConsumedODataService) HeadersItems() []element.Element { + return o.headers.Items() +} + +// AddHeaders appends a child element to the headers list. +func (o *ConsumedODataService) AddHeaders(v element.Element) { + o.headers.Append(v) +} + +// RemoveHeaders removes the element at the given index from the headers list. +func (o *ConsumedODataService) RemoveHeaders(index int) { + o.headers.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConsumedODataService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.description.Init(raw) + o.catalogUrl.Init(raw) + o.icon.Init(raw) + o.metadata.Init(raw) + o.metadataUrl.Init(raw) + o.serviceName.Init(raw) + o.version.Init(raw) + o.endpointId.Init(raw) + o.minimumMxVersion.Init(raw) + o.recommendedMxVersion.Init(raw) + o.applicationId.Init(raw) + if val, err := raw.LookupErr("EnvironmentType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.environmentType.SetFromDecode(s) } + } + o.metadataHash.Init(raw) + o.validated.Init(raw) + o.validatedEntities.Init(raw) + if children, err := codec.DecodeChildren(raw, "MetadataReferences"); err == nil { + for _, child := range children { + o.metadataReferences.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("ProxyType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.proxyType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ProxyHost"); err == nil { + if s, ok := val.StringValueOK(); ok { o.proxyHost.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ProxyPort"); err == nil { + if s, ok := val.StringValueOK(); ok { o.proxyPort.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ProxyUsername"); err == nil { + if s, ok := val.StringValueOK(); ok { o.proxyUsername.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ProxyPassword"); err == nil { + if s, ok := val.StringValueOK(); ok { o.proxyPassword.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "HttpConfiguration"); err == nil { + o.httpConfiguration.SetFromDecode(child) + } + if val, err := raw.LookupErr("HeadersMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.headersMicroflow.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ConfigurationMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.configurationMicroflow.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "TimeoutModel"); err == nil { + o.timeoutModel.SetFromDecode(child) + } + o.timeoutExpression.Init(raw) + if val, err := raw.LookupErr("ODataVersion"); err == nil { + if s, ok := val.StringValueOK(); ok { o.oDataVersion.SetFromDecode(s) } + } + o.versionApiMockResults.Init(raw) + o.serviceId.Init(raw) + o.lastUpdated.Init(raw) + o.useQuerySegment.Init(raw) + if val, err := raw.LookupErr("ErrorHandlingMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.errorHandlingMicroflow.SetFromDecode(s) } + } + o.serviceUrl.Init(raw) + o.httpUsername.Init(raw) + o.httpPassword.Init(raw) + o.useAuthentication.Init(raw) + o.clientCertificate.Init(raw) + if children, err := codec.DecodeChildren(raw, "Headers"); err == nil { + for _, child := range children { + o.headers.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ConsumedRestService +// ──────────────────────────────────────────────────────── + +type ConsumedRestService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + openApiFile *property.Part[element.Element] + baseUrl *property.Part[element.Element] + authenticationScheme *property.Part[element.Element] + operations *property.PartList[element.Element] + baseUrlParameter *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *ConsumedRestService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConsumedRestService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ConsumedRestService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ConsumedRestService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ConsumedRestService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ConsumedRestService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ConsumedRestService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ConsumedRestService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// OpenApiFile returns the value of the openApiFile property. +func (o *ConsumedRestService) OpenApiFile() element.Element { + return o.openApiFile.Get() +} + +// SetOpenApiFile sets the value of the openApiFile property. +func (o *ConsumedRestService) SetOpenApiFile(v element.Element) { + o.openApiFile.Set(v) +} + +// BaseUrl returns the value of the baseUrl property. +func (o *ConsumedRestService) BaseUrl() element.Element { + return o.baseUrl.Get() +} + +// SetBaseUrl sets the value of the baseUrl property. +func (o *ConsumedRestService) SetBaseUrl(v element.Element) { + o.baseUrl.Set(v) +} + +// AuthenticationScheme returns the value of the authenticationScheme property. +func (o *ConsumedRestService) AuthenticationScheme() element.Element { + return o.authenticationScheme.Get() +} + +// SetAuthenticationScheme sets the value of the authenticationScheme property. +func (o *ConsumedRestService) SetAuthenticationScheme(v element.Element) { + o.authenticationScheme.Set(v) +} + +// OperationsItems returns the value of the operations property. +func (o *ConsumedRestService) OperationsItems() []element.Element { + return o.operations.Items() +} + +// AddOperations appends a child element to the operations list. +func (o *ConsumedRestService) AddOperations(v element.Element) { + o.operations.Append(v) +} + +// RemoveOperations removes the element at the given index from the operations list. +func (o *ConsumedRestService) RemoveOperations(index int) { + o.operations.Remove(index) +} + +// BaseUrlParameter returns the value of the baseUrlParameter property. +func (o *ConsumedRestService) BaseUrlParameter() element.Element { + return o.baseUrlParameter.Get() +} + +// SetBaseUrlParameter sets the value of the baseUrlParameter property. +func (o *ConsumedRestService) SetBaseUrlParameter(v element.Element) { + o.baseUrlParameter.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConsumedRestService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "OpenApiFile"); err == nil { + o.openApiFile.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "BaseUrl"); err == nil { + o.baseUrl.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "AuthenticationScheme"); err == nil { + o.authenticationScheme.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Operations"); err == nil { + for _, child := range children { + o.operations.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "BaseUrlParameter"); err == nil { + o.baseUrlParameter.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// CorsConfiguration +// ──────────────────────────────────────────────────────── + +type CorsConfiguration struct { + element.Base + allowedOrigins *property.ByNameRef[element.Element] + allowAuthentication *property.Primitive[bool] + maxAge *property.ByNameRef[element.Element] +} + +// AllowedOriginsQualifiedName returns the value of the allowedOrigins property. +func (o *CorsConfiguration) AllowedOriginsQualifiedName() string { + return o.allowedOrigins.QualifiedName() +} + +// SetAllowedOriginsQualifiedName sets the value of the allowedOrigins property. +func (o *CorsConfiguration) SetAllowedOriginsQualifiedName(v string) { + o.allowedOrigins.SetQualifiedName(v) +} + +// AllowAuthentication returns the value of the allowAuthentication property. +func (o *CorsConfiguration) AllowAuthentication() bool { + return o.allowAuthentication.Get() +} + +// SetAllowAuthentication sets the value of the allowAuthentication property. +func (o *CorsConfiguration) SetAllowAuthentication(v bool) { + o.allowAuthentication.Set(v) +} + +// MaxAgeQualifiedName returns the value of the maxAge property. +func (o *CorsConfiguration) MaxAgeQualifiedName() string { + return o.maxAge.QualifiedName() +} + +// SetMaxAgeQualifiedName sets the value of the maxAge property. +func (o *CorsConfiguration) SetMaxAgeQualifiedName(v string) { + o.maxAge.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CorsConfiguration) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("AllowedOrigins"); err == nil { + if s, ok := val.StringValueOK(); ok { o.allowedOrigins.SetFromDecode(s) } + } + o.allowAuthentication.Init(raw) + if val, err := raw.LookupErr("MaxAge"); err == nil { + if s, ok := val.StringValueOK(); ok { o.maxAge.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// HeaderWithValueTemplate +// ──────────────────────────────────────────────────────── + +type HeaderWithValueTemplate struct { + element.Base + name *property.Primitive[string] + value *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *HeaderWithValueTemplate) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *HeaderWithValueTemplate) SetName(v string) { + o.name.Set(v) +} + +// Value returns the value of the value property. +func (o *HeaderWithValueTemplate) Value() element.Element { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *HeaderWithValueTemplate) SetValue(v element.Element) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *HeaderWithValueTemplate) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Value"); err == nil { + o.value.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ImplicitMappingBody +// ──────────────────────────────────────────────────────── + +type ImplicitMappingBody struct { + element.Base + rootMappingElement *property.Part[element.Element] + testValue *property.Part[element.Element] +} + +// RootMappingElement returns the value of the rootMappingElement property. +func (o *ImplicitMappingBody) RootMappingElement() element.Element { + return o.rootMappingElement.Get() +} + +// SetRootMappingElement sets the value of the rootMappingElement property. +func (o *ImplicitMappingBody) SetRootMappingElement(v element.Element) { + o.rootMappingElement.Set(v) +} + +// TestValue returns the value of the testValue property. +func (o *ImplicitMappingBody) TestValue() element.Element { + return o.testValue.Get() +} + +// SetTestValue sets the value of the testValue property. +func (o *ImplicitMappingBody) SetTestValue(v element.Element) { + o.testValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImplicitMappingBody) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "RootMappingElement"); err == nil { + o.rootMappingElement.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TestValue"); err == nil { + o.testValue.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// RestOperationResponseHandling +// ──────────────────────────────────────────────────────── + +type RestOperationResponseHandling struct { + element.Base + statusCode *property.Primitive[int32] + contentType *property.Primitive[string] +} + +// StatusCode returns the value of the statusCode property. +func (o *RestOperationResponseHandling) StatusCode() int32 { + return o.statusCode.Get() +} + +// SetStatusCode sets the value of the statusCode property. +func (o *RestOperationResponseHandling) SetStatusCode(v int32) { + o.statusCode.Set(v) +} + +// ContentType returns the value of the contentType property. +func (o *RestOperationResponseHandling) ContentType() string { + return o.contentType.Get() +} + +// SetContentType sets the value of the contentType property. +func (o *RestOperationResponseHandling) SetContentType(v string) { + o.contentType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestOperationResponseHandling) InitFromRaw(raw bson.Raw) { + o.statusCode.Init(raw) + o.contentType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ImplicitMappingResponseHandling +// ──────────────────────────────────────────────────────── + +type ImplicitMappingResponseHandling struct { + element.Base + statusCode *property.Primitive[int32] + contentType *property.Primitive[string] + rootMappingElement *property.Part[element.Element] +} + +// StatusCode returns the value of the statusCode property. +func (o *ImplicitMappingResponseHandling) StatusCode() int32 { + return o.statusCode.Get() +} + +// SetStatusCode sets the value of the statusCode property. +func (o *ImplicitMappingResponseHandling) SetStatusCode(v int32) { + o.statusCode.Set(v) +} + +// ContentType returns the value of the contentType property. +func (o *ImplicitMappingResponseHandling) ContentType() string { + return o.contentType.Get() +} + +// SetContentType sets the value of the contentType property. +func (o *ImplicitMappingResponseHandling) SetContentType(v string) { + o.contentType.Set(v) +} + +// RootMappingElement returns the value of the rootMappingElement property. +func (o *ImplicitMappingResponseHandling) RootMappingElement() element.Element { + return o.rootMappingElement.Get() +} + +// SetRootMappingElement sets the value of the rootMappingElement property. +func (o *ImplicitMappingResponseHandling) SetRootMappingElement(v element.Element) { + o.rootMappingElement.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImplicitMappingResponseHandling) InitFromRaw(raw bson.Raw) { + o.statusCode.Init(raw) + o.contentType.Init(raw) + if child, err := codec.DecodeChild(raw, "RootMappingElement"); err == nil { + o.rootMappingElement.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// JsonBody +// ──────────────────────────────────────────────────────── + +type JsonBody struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *JsonBody) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *JsonBody) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JsonBody) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MetadataReference +// ──────────────────────────────────────────────────────── + +type MetadataReference struct { + element.Base + uri *property.Primitive[string] + metadata *property.Primitive[string] + metadataReferences *property.PartList[element.Element] +} + +// Uri returns the value of the uri property. +func (o *MetadataReference) Uri() string { + return o.uri.Get() +} + +// SetUri sets the value of the uri property. +func (o *MetadataReference) SetUri(v string) { + o.uri.Set(v) +} + +// Metadata returns the value of the metadata property. +func (o *MetadataReference) Metadata() string { + return o.metadata.Get() +} + +// SetMetadata sets the value of the metadata property. +func (o *MetadataReference) SetMetadata(v string) { + o.metadata.Set(v) +} + +// MetadataReferencesItems returns the value of the metadataReferences property. +func (o *MetadataReference) MetadataReferencesItems() []element.Element { + return o.metadataReferences.Items() +} + +// AddMetadataReferences appends a child element to the metadataReferences list. +func (o *MetadataReference) AddMetadataReferences(v element.Element) { + o.metadataReferences.Append(v) +} + +// RemoveMetadataReferences removes the element at the given index from the metadataReferences list. +func (o *MetadataReference) RemoveMetadataReferences(index int) { + o.metadataReferences.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MetadataReference) InitFromRaw(raw bson.Raw) { + o.uri.Init(raw) + o.metadata.Init(raw) + if children, err := codec.DecodeChildren(raw, "MetadataReferences"); err == nil { + for _, child := range children { + o.metadataReferences.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// NoResponseHandling +// ──────────────────────────────────────────────────────── + +type NoResponseHandling struct { + element.Base + statusCode *property.Primitive[int32] + contentType *property.Primitive[string] +} + +// StatusCode returns the value of the statusCode property. +func (o *NoResponseHandling) StatusCode() int32 { + return o.statusCode.Get() +} + +// SetStatusCode sets the value of the statusCode property. +func (o *NoResponseHandling) SetStatusCode(v int32) { + o.statusCode.Set(v) +} + +// ContentType returns the value of the contentType property. +func (o *NoResponseHandling) ContentType() string { + return o.contentType.Get() +} + +// SetContentType sets the value of the contentType property. +func (o *NoResponseHandling) SetContentType(v string) { + o.contentType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NoResponseHandling) InitFromRaw(raw bson.Raw) { + o.statusCode.Init(raw) + o.contentType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ODataEntityTypeSource +// ──────────────────────────────────────────────────────── + +type ODataEntityTypeSource struct { + element.Base + sourceDocument *property.ByNameRef[element.Element] + entityTypeName *property.Primitive[string] + key *property.Part[element.Element] + isOpen *property.Primitive[bool] +} + +// SourceDocumentQualifiedName returns the value of the sourceDocument property. +func (o *ODataEntityTypeSource) SourceDocumentQualifiedName() string { + return o.sourceDocument.QualifiedName() +} + +// SetSourceDocumentQualifiedName sets the value of the sourceDocument property. +func (o *ODataEntityTypeSource) SetSourceDocumentQualifiedName(v string) { + o.sourceDocument.SetQualifiedName(v) +} + +// EntityTypeName returns the value of the entityTypeName property. +func (o *ODataEntityTypeSource) EntityTypeName() string { + return o.entityTypeName.Get() +} + +// SetEntityTypeName sets the value of the entityTypeName property. +func (o *ODataEntityTypeSource) SetEntityTypeName(v string) { + o.entityTypeName.Set(v) +} + +// Key returns the value of the key property. +func (o *ODataEntityTypeSource) Key() element.Element { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *ODataEntityTypeSource) SetKey(v element.Element) { + o.key.Set(v) +} + +// IsOpen returns the value of the isOpen property. +func (o *ODataEntityTypeSource) IsOpen() bool { + return o.isOpen.Get() +} + +// SetIsOpen sets the value of the isOpen property. +func (o *ODataEntityTypeSource) SetIsOpen(v bool) { + o.isOpen.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataEntityTypeSource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("SourceDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { o.sourceDocument.SetFromDecode(s) } + } + o.entityTypeName.Init(raw) + if child, err := codec.DecodeChild(raw, "Key"); err == nil { + o.key.SetFromDecode(child) + } + o.isOpen.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ODataKey +// ──────────────────────────────────────────────────────── + +type ODataKey struct { + element.Base + parts *property.PartList[element.Element] +} + +// PartsItems returns the value of the parts property. +func (o *ODataKey) PartsItems() []element.Element { + return o.parts.Items() +} + +// AddParts appends a child element to the parts list. +func (o *ODataKey) AddParts(v element.Element) { + o.parts.Append(v) +} + +// RemoveParts removes the element at the given index from the parts list. +func (o *ODataKey) RemoveParts(index int) { + o.parts.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataKey) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Parts"); err == nil { + for _, child := range children { + o.parts.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ODataKeyPart +// ──────────────────────────────────────────────────────── + +type ODataKeyPart struct { + element.Base + name *property.Primitive[string] + entityKeyPartName *property.Primitive[string] + propType *property.Part[element.Element] + remoteType *property.Primitive[string] + filterable *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *ODataKeyPart) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ODataKeyPart) SetName(v string) { + o.name.Set(v) +} + +// EntityKeyPartName returns the value of the entityKeyPartName property. +func (o *ODataKeyPart) EntityKeyPartName() string { + return o.entityKeyPartName.Get() +} + +// SetEntityKeyPartName sets the value of the entityKeyPartName property. +func (o *ODataKeyPart) SetEntityKeyPartName(v string) { + o.entityKeyPartName.Set(v) +} + +// Type returns the value of the type property. +func (o *ODataKeyPart) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *ODataKeyPart) SetType(v element.Element) { + o.propType.Set(v) +} + +// RemoteType returns the value of the remoteType property. +func (o *ODataKeyPart) RemoteType() string { + return o.remoteType.Get() +} + +// SetRemoteType sets the value of the remoteType property. +func (o *ODataKeyPart) SetRemoteType(v string) { + o.remoteType.Set(v) +} + +// Filterable returns the value of the filterable property. +func (o *ODataKeyPart) Filterable() bool { + return o.filterable.Get() +} + +// SetFilterable sets the value of the filterable property. +func (o *ODataKeyPart) SetFilterable(v bool) { + o.filterable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataKeyPart) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.entityKeyPartName.Init(raw) + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } + o.remoteType.Init(raw) + o.filterable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ODataMappedPrimitiveCollectionValue +// ──────────────────────────────────────────────────────── + +type ODataMappedPrimitiveCollectionValue struct { + element.Base + defaultValueDesignTime *property.Primitive[string] + remoteName *property.Primitive[string] + remoteType *property.Primitive[string] +} + +// DefaultValueDesignTime returns the value of the defaultValueDesignTime property. +func (o *ODataMappedPrimitiveCollectionValue) DefaultValueDesignTime() string { + return o.defaultValueDesignTime.Get() +} + +// SetDefaultValueDesignTime sets the value of the defaultValueDesignTime property. +func (o *ODataMappedPrimitiveCollectionValue) SetDefaultValueDesignTime(v string) { + o.defaultValueDesignTime.Set(v) +} + +// RemoteName returns the value of the remoteName property. +func (o *ODataMappedPrimitiveCollectionValue) RemoteName() string { + return o.remoteName.Get() +} + +// SetRemoteName sets the value of the remoteName property. +func (o *ODataMappedPrimitiveCollectionValue) SetRemoteName(v string) { + o.remoteName.Set(v) +} + +// RemoteType returns the value of the remoteType property. +func (o *ODataMappedPrimitiveCollectionValue) RemoteType() string { + return o.remoteType.Get() +} + +// SetRemoteType sets the value of the remoteType property. +func (o *ODataMappedPrimitiveCollectionValue) SetRemoteType(v string) { + o.remoteType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataMappedPrimitiveCollectionValue) InitFromRaw(raw bson.Raw) { + o.defaultValueDesignTime.Init(raw) + o.remoteName.Init(raw) + o.remoteType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ODataMappedValue +// ──────────────────────────────────────────────────────── + +type ODataMappedValue struct { + element.Base + defaultValueDesignTime *property.Primitive[string] + remoteName *property.Primitive[string] + remoteType *property.Primitive[string] + filterable *property.Primitive[bool] + sortable *property.Primitive[bool] + representsStream *property.Primitive[bool] + updatable *property.Primitive[bool] + creatable *property.Primitive[bool] +} + +// DefaultValueDesignTime returns the value of the defaultValueDesignTime property. +func (o *ODataMappedValue) DefaultValueDesignTime() string { + return o.defaultValueDesignTime.Get() +} + +// SetDefaultValueDesignTime sets the value of the defaultValueDesignTime property. +func (o *ODataMappedValue) SetDefaultValueDesignTime(v string) { + o.defaultValueDesignTime.Set(v) +} + +// RemoteName returns the value of the remoteName property. +func (o *ODataMappedValue) RemoteName() string { + return o.remoteName.Get() +} + +// SetRemoteName sets the value of the remoteName property. +func (o *ODataMappedValue) SetRemoteName(v string) { + o.remoteName.Set(v) +} + +// RemoteType returns the value of the remoteType property. +func (o *ODataMappedValue) RemoteType() string { + return o.remoteType.Get() +} + +// SetRemoteType sets the value of the remoteType property. +func (o *ODataMappedValue) SetRemoteType(v string) { + o.remoteType.Set(v) +} + +// Filterable returns the value of the filterable property. +func (o *ODataMappedValue) Filterable() bool { + return o.filterable.Get() +} + +// SetFilterable sets the value of the filterable property. +func (o *ODataMappedValue) SetFilterable(v bool) { + o.filterable.Set(v) +} + +// Sortable returns the value of the sortable property. +func (o *ODataMappedValue) Sortable() bool { + return o.sortable.Get() +} + +// SetSortable sets the value of the sortable property. +func (o *ODataMappedValue) SetSortable(v bool) { + o.sortable.Set(v) +} + +// RepresentsStream returns the value of the representsStream property. +func (o *ODataMappedValue) RepresentsStream() bool { + return o.representsStream.Get() +} + +// SetRepresentsStream sets the value of the representsStream property. +func (o *ODataMappedValue) SetRepresentsStream(v bool) { + o.representsStream.Set(v) +} + +// Updatable returns the value of the updatable property. +func (o *ODataMappedValue) Updatable() bool { + return o.updatable.Get() +} + +// SetUpdatable sets the value of the updatable property. +func (o *ODataMappedValue) SetUpdatable(v bool) { + o.updatable.Set(v) +} + +// Creatable returns the value of the creatable property. +func (o *ODataMappedValue) Creatable() bool { + return o.creatable.Get() +} + +// SetCreatable sets the value of the creatable property. +func (o *ODataMappedValue) SetCreatable(v bool) { + o.creatable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataMappedValue) InitFromRaw(raw bson.Raw) { + o.defaultValueDesignTime.Init(raw) + o.remoteName.Init(raw) + o.remoteType.Init(raw) + o.filterable.Init(raw) + o.sortable.Init(raw) + o.representsStream.Init(raw) + o.updatable.Init(raw) + o.creatable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ODataPrimitiveCollectionAssociationSource +// ──────────────────────────────────────────────────────── + +type ODataPrimitiveCollectionAssociationSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *ODataPrimitiveCollectionAssociationSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *ODataPrimitiveCollectionAssociationSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *ODataPrimitiveCollectionAssociationSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *ODataPrimitiveCollectionAssociationSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *ODataPrimitiveCollectionAssociationSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *ODataPrimitiveCollectionAssociationSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ODataPrimitiveCollectionAssociationSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ODataPrimitiveCollectionAssociationSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataPrimitiveCollectionAssociationSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ODataPrimitiveCollectionEntitySource +// ──────────────────────────────────────────────────────── + +type ODataPrimitiveCollectionEntitySource struct { + element.Base + sourceDocument *property.ByNameRef[element.Element] +} + +// SourceDocumentQualifiedName returns the value of the sourceDocument property. +func (o *ODataPrimitiveCollectionEntitySource) SourceDocumentQualifiedName() string { + return o.sourceDocument.QualifiedName() +} + +// SetSourceDocumentQualifiedName sets the value of the sourceDocument property. +func (o *ODataPrimitiveCollectionEntitySource) SetSourceDocumentQualifiedName(v string) { + o.sourceDocument.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataPrimitiveCollectionEntitySource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("SourceDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { o.sourceDocument.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ODataRemoteAssociationSource +// ──────────────────────────────────────────────────────── + +type ODataRemoteAssociationSource struct { + element.Base + forceFullObjects *property.Primitive[bool] + entityPath *property.Primitive[string] + entityRef *property.Part[element.Element] + sourceVariable *property.Part[element.Element] + remoteParentNavigationProperty *property.Primitive[string] + remoteChildNavigationProperty *property.Primitive[string] + navigability *property.Enum[string] + navigability2 *property.Enum[string] + updatableFromChild *property.Primitive[bool] + updatableFromParent *property.Primitive[bool] + creatableFromChild *property.Primitive[bool] + creatableFromParent *property.Primitive[bool] +} + +// ForceFullObjects returns the value of the forceFullObjects property. +func (o *ODataRemoteAssociationSource) ForceFullObjects() bool { + return o.forceFullObjects.Get() +} + +// SetForceFullObjects sets the value of the forceFullObjects property. +func (o *ODataRemoteAssociationSource) SetForceFullObjects(v bool) { + o.forceFullObjects.Set(v) +} + +// EntityPath returns the value of the entityPath property. +func (o *ODataRemoteAssociationSource) EntityPath() string { + return o.entityPath.Get() +} + +// SetEntityPath sets the value of the entityPath property. +func (o *ODataRemoteAssociationSource) SetEntityPath(v string) { + o.entityPath.Set(v) +} + +// EntityRef returns the value of the entityRef property. +func (o *ODataRemoteAssociationSource) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *ODataRemoteAssociationSource) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// SourceVariable returns the value of the sourceVariable property. +func (o *ODataRemoteAssociationSource) SourceVariable() element.Element { + return o.sourceVariable.Get() +} + +// SetSourceVariable sets the value of the sourceVariable property. +func (o *ODataRemoteAssociationSource) SetSourceVariable(v element.Element) { + o.sourceVariable.Set(v) +} + +// RemoteParentNavigationProperty returns the value of the remoteParentNavigationProperty property. +func (o *ODataRemoteAssociationSource) RemoteParentNavigationProperty() string { + return o.remoteParentNavigationProperty.Get() +} + +// SetRemoteParentNavigationProperty sets the value of the remoteParentNavigationProperty property. +func (o *ODataRemoteAssociationSource) SetRemoteParentNavigationProperty(v string) { + o.remoteParentNavigationProperty.Set(v) +} + +// RemoteChildNavigationProperty returns the value of the remoteChildNavigationProperty property. +func (o *ODataRemoteAssociationSource) RemoteChildNavigationProperty() string { + return o.remoteChildNavigationProperty.Get() +} + +// SetRemoteChildNavigationProperty sets the value of the remoteChildNavigationProperty property. +func (o *ODataRemoteAssociationSource) SetRemoteChildNavigationProperty(v string) { + o.remoteChildNavigationProperty.Set(v) +} + +// Navigability returns the value of the navigability property. +func (o *ODataRemoteAssociationSource) Navigability() string { + return o.navigability.Get() +} + +// SetNavigability sets the value of the navigability property. +func (o *ODataRemoteAssociationSource) SetNavigability(v string) { + o.navigability.Set(v) +} + +// Navigability2 returns the value of the navigability2 property. +func (o *ODataRemoteAssociationSource) Navigability2() string { + return o.navigability2.Get() +} + +// SetNavigability2 sets the value of the navigability2 property. +func (o *ODataRemoteAssociationSource) SetNavigability2(v string) { + o.navigability2.Set(v) +} + +// UpdatableFromChild returns the value of the updatableFromChild property. +func (o *ODataRemoteAssociationSource) UpdatableFromChild() bool { + return o.updatableFromChild.Get() +} + +// SetUpdatableFromChild sets the value of the updatableFromChild property. +func (o *ODataRemoteAssociationSource) SetUpdatableFromChild(v bool) { + o.updatableFromChild.Set(v) +} + +// UpdatableFromParent returns the value of the updatableFromParent property. +func (o *ODataRemoteAssociationSource) UpdatableFromParent() bool { + return o.updatableFromParent.Get() +} + +// SetUpdatableFromParent sets the value of the updatableFromParent property. +func (o *ODataRemoteAssociationSource) SetUpdatableFromParent(v bool) { + o.updatableFromParent.Set(v) +} + +// CreatableFromChild returns the value of the creatableFromChild property. +func (o *ODataRemoteAssociationSource) CreatableFromChild() bool { + return o.creatableFromChild.Get() +} + +// SetCreatableFromChild sets the value of the creatableFromChild property. +func (o *ODataRemoteAssociationSource) SetCreatableFromChild(v bool) { + o.creatableFromChild.Set(v) +} + +// CreatableFromParent returns the value of the creatableFromParent property. +func (o *ODataRemoteAssociationSource) CreatableFromParent() bool { + return o.creatableFromParent.Get() +} + +// SetCreatableFromParent sets the value of the creatableFromParent property. +func (o *ODataRemoteAssociationSource) SetCreatableFromParent(v bool) { + o.creatableFromParent.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataRemoteAssociationSource) InitFromRaw(raw bson.Raw) { + o.forceFullObjects.Init(raw) + o.entityPath.Init(raw) + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "SourceVariable"); err == nil { + o.sourceVariable.SetFromDecode(child) + } + o.remoteParentNavigationProperty.Init(raw) + o.remoteChildNavigationProperty.Init(raw) + if val, err := raw.LookupErr("Navigability"); err == nil { + if s, ok := val.StringValueOK(); ok { o.navigability.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Navigability2"); err == nil { + if s, ok := val.StringValueOK(); ok { o.navigability2.SetFromDecode(s) } + } + o.updatableFromChild.Init(raw) + o.updatableFromParent.Init(raw) + o.creatableFromChild.Init(raw) + o.creatableFromParent.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ODataRemoteEntitySource +// ──────────────────────────────────────────────────────── + +type ODataRemoteEntitySource struct { + element.Base + sourceDocument *property.ByNameRef[element.Element] + remoteName *property.Primitive[string] + entityTypeName *property.Primitive[string] + entitySet *property.Primitive[string] + entitySetName *property.Primitive[string] + key *property.Part[element.Element] + countable *property.Primitive[bool] + creatable *property.Primitive[bool] + deletable *property.Primitive[bool] + topSupported *property.Primitive[bool] + skipSupported *property.Primitive[bool] + createChangeLocally *property.Primitive[bool] +} + +// SourceDocumentQualifiedName returns the value of the sourceDocument property. +func (o *ODataRemoteEntitySource) SourceDocumentQualifiedName() string { + return o.sourceDocument.QualifiedName() +} + +// SetSourceDocumentQualifiedName sets the value of the sourceDocument property. +func (o *ODataRemoteEntitySource) SetSourceDocumentQualifiedName(v string) { + o.sourceDocument.SetQualifiedName(v) +} + +// RemoteName returns the value of the remoteName property. +func (o *ODataRemoteEntitySource) RemoteName() string { + return o.remoteName.Get() +} + +// SetRemoteName sets the value of the remoteName property. +func (o *ODataRemoteEntitySource) SetRemoteName(v string) { + o.remoteName.Set(v) +} + +// EntityTypeName returns the value of the entityTypeName property. +func (o *ODataRemoteEntitySource) EntityTypeName() string { + return o.entityTypeName.Get() +} + +// SetEntityTypeName sets the value of the entityTypeName property. +func (o *ODataRemoteEntitySource) SetEntityTypeName(v string) { + o.entityTypeName.Set(v) +} + +// EntitySet returns the value of the entitySet property. +func (o *ODataRemoteEntitySource) EntitySet() string { + return o.entitySet.Get() +} + +// SetEntitySet sets the value of the entitySet property. +func (o *ODataRemoteEntitySource) SetEntitySet(v string) { + o.entitySet.Set(v) +} + +// EntitySetName returns the value of the entitySetName property. +func (o *ODataRemoteEntitySource) EntitySetName() string { + return o.entitySetName.Get() +} + +// SetEntitySetName sets the value of the entitySetName property. +func (o *ODataRemoteEntitySource) SetEntitySetName(v string) { + o.entitySetName.Set(v) +} + +// Key returns the value of the key property. +func (o *ODataRemoteEntitySource) Key() element.Element { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *ODataRemoteEntitySource) SetKey(v element.Element) { + o.key.Set(v) +} + +// Countable returns the value of the countable property. +func (o *ODataRemoteEntitySource) Countable() bool { + return o.countable.Get() +} + +// SetCountable sets the value of the countable property. +func (o *ODataRemoteEntitySource) SetCountable(v bool) { + o.countable.Set(v) +} + +// Creatable returns the value of the creatable property. +func (o *ODataRemoteEntitySource) Creatable() bool { + return o.creatable.Get() +} + +// SetCreatable sets the value of the creatable property. +func (o *ODataRemoteEntitySource) SetCreatable(v bool) { + o.creatable.Set(v) +} + +// Deletable returns the value of the deletable property. +func (o *ODataRemoteEntitySource) Deletable() bool { + return o.deletable.Get() +} + +// SetDeletable sets the value of the deletable property. +func (o *ODataRemoteEntitySource) SetDeletable(v bool) { + o.deletable.Set(v) +} + +// TopSupported returns the value of the topSupported property. +func (o *ODataRemoteEntitySource) TopSupported() bool { + return o.topSupported.Get() +} + +// SetTopSupported sets the value of the topSupported property. +func (o *ODataRemoteEntitySource) SetTopSupported(v bool) { + o.topSupported.Set(v) +} + +// SkipSupported returns the value of the skipSupported property. +func (o *ODataRemoteEntitySource) SkipSupported() bool { + return o.skipSupported.Get() +} + +// SetSkipSupported sets the value of the skipSupported property. +func (o *ODataRemoteEntitySource) SetSkipSupported(v bool) { + o.skipSupported.Set(v) +} + +// CreateChangeLocally returns the value of the createChangeLocally property. +func (o *ODataRemoteEntitySource) CreateChangeLocally() bool { + return o.createChangeLocally.Get() +} + +// SetCreateChangeLocally sets the value of the createChangeLocally property. +func (o *ODataRemoteEntitySource) SetCreateChangeLocally(v bool) { + o.createChangeLocally.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataRemoteEntitySource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("SourceDocument"); err == nil { + if s, ok := val.StringValueOK(); ok { o.sourceDocument.SetFromDecode(s) } + } + o.remoteName.Init(raw) + o.entityTypeName.Init(raw) + o.entitySet.Init(raw) + o.entitySetName.Init(raw) + if child, err := codec.DecodeChild(raw, "Key"); err == nil { + o.key.SetFromDecode(child) + } + o.countable.Init(raw) + o.creatable.Init(raw) + o.deletable.Init(raw) + o.topSupported.Init(raw) + o.skipSupported.Init(raw) + o.createChangeLocally.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ODataRemoteEnumerationSource +// ──────────────────────────────────────────────────────── + +type ODataRemoteEnumerationSource struct { + element.Base + consumedODataService *property.ByNameRef[element.Element] + remoteName *property.Primitive[string] +} + +// ConsumedODataServiceQualifiedName returns the value of the consumedODataService property. +func (o *ODataRemoteEnumerationSource) ConsumedODataServiceQualifiedName() string { + return o.consumedODataService.QualifiedName() +} + +// SetConsumedODataServiceQualifiedName sets the value of the consumedODataService property. +func (o *ODataRemoteEnumerationSource) SetConsumedODataServiceQualifiedName(v string) { + o.consumedODataService.SetQualifiedName(v) +} + +// RemoteName returns the value of the remoteName property. +func (o *ODataRemoteEnumerationSource) RemoteName() string { + return o.remoteName.Get() +} + +// SetRemoteName sets the value of the remoteName property. +func (o *ODataRemoteEnumerationSource) SetRemoteName(v string) { + o.remoteName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataRemoteEnumerationSource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ConsumedODataService"); err == nil { + if s, ok := val.StringValueOK(); ok { o.consumedODataService.SetFromDecode(s) } + } + o.remoteName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ODataRemoteEnumerationValue +// ──────────────────────────────────────────────────────── + +type ODataRemoteEnumerationValue struct { + element.Base + remoteName *property.Primitive[string] +} + +// RemoteName returns the value of the remoteName property. +func (o *ODataRemoteEnumerationValue) RemoteName() string { + return o.remoteName.Get() +} + +// SetRemoteName sets the value of the remoteName property. +func (o *ODataRemoteEnumerationValue) SetRemoteName(v string) { + o.remoteName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ODataRemoteEnumerationValue) InitFromRaw(raw bson.Raw) { + o.remoteName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OpenApiFile +// ──────────────────────────────────────────────────────── + +type OpenApiFile struct { + element.Base + content *property.Primitive[string] +} + +// Content returns the value of the content property. +func (o *OpenApiFile) Content() string { + return o.content.Get() +} + +// SetContent sets the value of the content property. +func (o *OpenApiFile) SetContent(v string) { + o.content.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OpenApiFile) InitFromRaw(raw bson.Raw) { + o.content.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OperationParameter +// ──────────────────────────────────────────────────────── + +type OperationParameter struct { + element.Base + name *property.Primitive[string] + dataType *property.Part[element.Element] + testValue *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *OperationParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *OperationParameter) SetName(v string) { + o.name.Set(v) +} + +// DataType returns the value of the dataType property. +func (o *OperationParameter) DataType() element.Element { + return o.dataType.Get() +} + +// SetDataType sets the value of the dataType property. +func (o *OperationParameter) SetDataType(v element.Element) { + o.dataType.Set(v) +} + +// TestValue returns the value of the testValue property. +func (o *OperationParameter) TestValue() element.Element { + return o.testValue.Get() +} + +// SetTestValue sets the value of the testValue property. +func (o *OperationParameter) SetTestValue(v element.Element) { + o.testValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OperationParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "DataType"); err == nil { + o.dataType.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TestValue"); err == nil { + o.testValue.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// QueryParameterUsage +// ──────────────────────────────────────────────────────── + +type QueryParameterUsage struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueryParameterUsage) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// OptionalQueryParameterUsage +// ──────────────────────────────────────────────────────── + +type OptionalQueryParameterUsage struct { + element.Base + included *property.Primitive[bool] +} + +// Included returns the value of the included property. +func (o *OptionalQueryParameterUsage) Included() bool { + return o.included.Get() +} + +// SetIncluded sets the value of the included property. +func (o *OptionalQueryParameterUsage) SetIncluded(v bool) { + o.included.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OptionalQueryParameterUsage) InitFromRaw(raw bson.Raw) { + o.included.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedODataContract +// ──────────────────────────────────────────────────────── + +type PublishedODataContract struct { + element.Base + serviceFeed *property.Part[element.Element] + metadata *property.Primitive[string] + openApi *property.Primitive[string] +} + +// ServiceFeed returns the value of the serviceFeed property. +func (o *PublishedODataContract) ServiceFeed() element.Element { + return o.serviceFeed.Get() +} + +// SetServiceFeed sets the value of the serviceFeed property. +func (o *PublishedODataContract) SetServiceFeed(v element.Element) { + o.serviceFeed.Set(v) +} + +// Metadata returns the value of the metadata property. +func (o *PublishedODataContract) Metadata() string { + return o.metadata.Get() +} + +// SetMetadata sets the value of the metadata property. +func (o *PublishedODataContract) SetMetadata(v string) { + o.metadata.Set(v) +} + +// OpenApi returns the value of the openApi property. +func (o *PublishedODataContract) OpenApi() string { + return o.openApi.Get() +} + +// SetOpenApi sets the value of the openApi property. +func (o *PublishedODataContract) SetOpenApi(v string) { + o.openApi.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedODataContract) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "ServiceFeed"); err == nil { + o.serviceFeed.SetFromDecode(child) + } + o.metadata.Init(raw) + o.openApi.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedODataEnumeration +// ──────────────────────────────────────────────────────── + +type PublishedODataEnumeration struct { + element.Base + exposedName *property.Primitive[string] + enumeration *property.ByNameRef[element.Element] + values *property.PartList[element.Element] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedODataEnumeration) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedODataEnumeration) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// EnumerationQualifiedName returns the value of the enumeration property. +func (o *PublishedODataEnumeration) EnumerationQualifiedName() string { + return o.enumeration.QualifiedName() +} + +// SetEnumerationQualifiedName sets the value of the enumeration property. +func (o *PublishedODataEnumeration) SetEnumerationQualifiedName(v string) { + o.enumeration.SetQualifiedName(v) +} + +// ValuesItems returns the value of the values property. +func (o *PublishedODataEnumeration) ValuesItems() []element.Element { + return o.values.Items() +} + +// AddValues appends a child element to the values list. +func (o *PublishedODataEnumeration) AddValues(v element.Element) { + o.values.Append(v) +} + +// RemoveValues removes the element at the given index from the values list. +func (o *PublishedODataEnumeration) RemoveValues(index int) { + o.values.Remove(index) +} + +// Summary returns the value of the summary property. +func (o *PublishedODataEnumeration) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedODataEnumeration) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedODataEnumeration) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedODataEnumeration) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedODataEnumeration) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("Enumeration"); err == nil { + if s, ok := val.StringValueOK(); ok { o.enumeration.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Values"); err == nil { + for _, child := range children { + o.values.AppendFromDecode(child) + } + } + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedODataEnumerationValue +// ──────────────────────────────────────────────────────── + +type PublishedODataEnumerationValue struct { + element.Base + exposedName *property.Primitive[string] + enumerationValue *property.ByNameRef[element.Element] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedODataEnumerationValue) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedODataEnumerationValue) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// EnumerationValueQualifiedName returns the value of the enumerationValue property. +func (o *PublishedODataEnumerationValue) EnumerationValueQualifiedName() string { + return o.enumerationValue.QualifiedName() +} + +// SetEnumerationValueQualifiedName sets the value of the enumerationValue property. +func (o *PublishedODataEnumerationValue) SetEnumerationValueQualifiedName(v string) { + o.enumerationValue.SetQualifiedName(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedODataEnumerationValue) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedODataEnumerationValue) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedODataEnumerationValue) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedODataEnumerationValue) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedODataEnumerationValue) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("EnumerationValue"); err == nil { + if s, ok := val.StringValueOK(); ok { o.enumerationValue.SetFromDecode(s) } + } + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedODataMicroflow +// ──────────────────────────────────────────────────────── + +type PublishedODataMicroflow struct { + element.Base + exposedName *property.Primitive[string] + microflow *property.ByNameRef[element.Element] + parameters *property.PartList[element.Element] + returnType *property.Part[element.Element] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedODataMicroflow) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedODataMicroflow) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *PublishedODataMicroflow) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *PublishedODataMicroflow) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *PublishedODataMicroflow) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *PublishedODataMicroflow) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *PublishedODataMicroflow) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// ReturnType returns the value of the returnType property. +func (o *PublishedODataMicroflow) ReturnType() element.Element { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *PublishedODataMicroflow) SetReturnType(v element.Element) { + o.returnType.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedODataMicroflow) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedODataMicroflow) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedODataMicroflow) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedODataMicroflow) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedODataMicroflow) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ReturnType"); err == nil { + o.returnType.SetFromDecode(child) + } + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedODataMicroflowParameter +// ──────────────────────────────────────────────────────── + +type PublishedODataMicroflowParameter struct { + element.Base + exposedName *property.Primitive[string] + microflowParameter *property.ByNameRef[element.Element] + propType *property.Part[element.Element] + dataType *property.Part[element.Element] + canBeEmpty *property.Primitive[bool] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedODataMicroflowParameter) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedODataMicroflowParameter) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// MicroflowParameterQualifiedName returns the value of the microflowParameter property. +func (o *PublishedODataMicroflowParameter) MicroflowParameterQualifiedName() string { + return o.microflowParameter.QualifiedName() +} + +// SetMicroflowParameterQualifiedName sets the value of the microflowParameter property. +func (o *PublishedODataMicroflowParameter) SetMicroflowParameterQualifiedName(v string) { + o.microflowParameter.SetQualifiedName(v) +} + +// Type returns the value of the type property. +func (o *PublishedODataMicroflowParameter) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *PublishedODataMicroflowParameter) SetType(v element.Element) { + o.propType.Set(v) +} + +// DataType returns the value of the dataType property. +func (o *PublishedODataMicroflowParameter) DataType() element.Element { + return o.dataType.Get() +} + +// SetDataType sets the value of the dataType property. +func (o *PublishedODataMicroflowParameter) SetDataType(v element.Element) { + o.dataType.Set(v) +} + +// CanBeEmpty returns the value of the canBeEmpty property. +func (o *PublishedODataMicroflowParameter) CanBeEmpty() bool { + return o.canBeEmpty.Get() +} + +// SetCanBeEmpty sets the value of the canBeEmpty property. +func (o *PublishedODataMicroflowParameter) SetCanBeEmpty(v bool) { + o.canBeEmpty.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedODataMicroflowParameter) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedODataMicroflowParameter) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedODataMicroflowParameter) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedODataMicroflowParameter) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedODataMicroflowParameter) InitFromRaw(raw bson.Raw) { + o.exposedName.Init(raw) + if val, err := raw.LookupErr("MicroflowParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflowParameter.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataType"); err == nil { + o.dataType.SetFromDecode(child) + } + o.canBeEmpty.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedODataService +// ──────────────────────────────────────────────────────── + +type PublishedODataService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + namespace *property.Primitive[string] + path *property.Primitive[string] + allowedModuleRoles *property.ByNameRefList[element.Element] + serviceName *property.Primitive[string] + resources *property.PartList[element.Element] + microflows *property.PartList[element.Element] + enumerations *property.PartList[element.Element] + publishAssociations *property.Primitive[bool] + version *property.Primitive[string] + authenticationMicroflow *property.ByNameRef[element.Element] + authenticationTypes *property.EnumList[string] + summary *property.Primitive[string] + description *property.Primitive[string] + replaceIllegalChars *property.Primitive[bool] + useGeneralization *property.Primitive[bool] + oDataVersion *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *PublishedODataService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedODataService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedODataService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedODataService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *PublishedODataService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *PublishedODataService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *PublishedODataService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *PublishedODataService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Namespace returns the value of the namespace property. +func (o *PublishedODataService) Namespace() string { + return o.namespace.Get() +} + +// SetNamespace sets the value of the namespace property. +func (o *PublishedODataService) SetNamespace(v string) { + o.namespace.Set(v) +} + +// Path returns the value of the path property. +func (o *PublishedODataService) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *PublishedODataService) SetPath(v string) { + o.path.Set(v) +} + +// AllowedModuleRolesQualifiedNames returns the value of the allowedModuleRoles property. +func (o *PublishedODataService) AllowedModuleRolesQualifiedNames() []string { + return o.allowedModuleRoles.QualifiedNames() +} + +// SetAllowedModuleRolesQualifiedNames sets the value of the allowedModuleRoles property. +func (o *PublishedODataService) SetAllowedModuleRolesQualifiedNames(v []string) { + o.allowedModuleRoles.SetQualifiedNames(v) +} + +// AddAllowedModuleRoles appends a child element to the allowedModuleRoles list. +func (o *PublishedODataService) AddAllowedModuleRoles(v string) { + o.allowedModuleRoles.Append(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *PublishedODataService) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *PublishedODataService) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// ResourcesItems returns the value of the resources property. +func (o *PublishedODataService) ResourcesItems() []element.Element { + return o.resources.Items() +} + +// AddResources appends a child element to the resources list. +func (o *PublishedODataService) AddResources(v element.Element) { + o.resources.Append(v) +} + +// RemoveResources removes the element at the given index from the resources list. +func (o *PublishedODataService) RemoveResources(index int) { + o.resources.Remove(index) +} + +// MicroflowsItems returns the value of the microflows property. +func (o *PublishedODataService) MicroflowsItems() []element.Element { + return o.microflows.Items() +} + +// AddMicroflows appends a child element to the microflows list. +func (o *PublishedODataService) AddMicroflows(v element.Element) { + o.microflows.Append(v) +} + +// RemoveMicroflows removes the element at the given index from the microflows list. +func (o *PublishedODataService) RemoveMicroflows(index int) { + o.microflows.Remove(index) +} + +// EnumerationsItems returns the value of the enumerations property. +func (o *PublishedODataService) EnumerationsItems() []element.Element { + return o.enumerations.Items() +} + +// AddEnumerations appends a child element to the enumerations list. +func (o *PublishedODataService) AddEnumerations(v element.Element) { + o.enumerations.Append(v) +} + +// RemoveEnumerations removes the element at the given index from the enumerations list. +func (o *PublishedODataService) RemoveEnumerations(index int) { + o.enumerations.Remove(index) +} + +// PublishAssociations returns the value of the publishAssociations property. +func (o *PublishedODataService) PublishAssociations() bool { + return o.publishAssociations.Get() +} + +// SetPublishAssociations sets the value of the publishAssociations property. +func (o *PublishedODataService) SetPublishAssociations(v bool) { + o.publishAssociations.Set(v) +} + +// Version returns the value of the version property. +func (o *PublishedODataService) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *PublishedODataService) SetVersion(v string) { + o.version.Set(v) +} + +// AuthenticationMicroflowQualifiedName returns the value of the authenticationMicroflow property. +func (o *PublishedODataService) AuthenticationMicroflowQualifiedName() string { + return o.authenticationMicroflow.QualifiedName() +} + +// SetAuthenticationMicroflowQualifiedName sets the value of the authenticationMicroflow property. +func (o *PublishedODataService) SetAuthenticationMicroflowQualifiedName(v string) { + o.authenticationMicroflow.SetQualifiedName(v) +} + +// AuthenticationTypesItems returns the value of the authenticationTypes property. +func (o *PublishedODataService) AuthenticationTypesItems() []string { + return o.authenticationTypes.Items() +} + +// AddAuthenticationTypes appends a child element to the authenticationTypes list. +func (o *PublishedODataService) AddAuthenticationTypes(v string) { + o.authenticationTypes.Append(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedODataService) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedODataService) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedODataService) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedODataService) SetDescription(v string) { + o.description.Set(v) +} + +// ReplaceIllegalChars returns the value of the replaceIllegalChars property. +func (o *PublishedODataService) ReplaceIllegalChars() bool { + return o.replaceIllegalChars.Get() +} + +// SetReplaceIllegalChars sets the value of the replaceIllegalChars property. +func (o *PublishedODataService) SetReplaceIllegalChars(v bool) { + o.replaceIllegalChars.Set(v) +} + +// UseGeneralization returns the value of the useGeneralization property. +func (o *PublishedODataService) UseGeneralization() bool { + return o.useGeneralization.Get() +} + +// SetUseGeneralization sets the value of the useGeneralization property. +func (o *PublishedODataService) SetUseGeneralization(v bool) { + o.useGeneralization.Set(v) +} + +// ODataVersion returns the value of the oDataVersion property. +func (o *PublishedODataService) ODataVersion() string { + return o.oDataVersion.Get() +} + +// SetODataVersion sets the value of the oDataVersion property. +func (o *PublishedODataService) SetODataVersion(v string) { + o.oDataVersion.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedODataService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.namespace.Init(raw) + o.path.Init(raw) + if val, err := raw.LookupErr("AllowedModuleRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.allowedModuleRoles.SetFromDecode(qnames) + } + } + o.serviceName.Init(raw) + if children, err := codec.DecodeChildren(raw, "Resources"); err == nil { + for _, child := range children { + o.resources.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Microflows"); err == nil { + for _, child := range children { + o.microflows.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Enumerations"); err == nil { + for _, child := range children { + o.enumerations.AppendFromDecode(child) + } + } + o.publishAssociations.Init(raw) + o.version.Init(raw) + if val, err := raw.LookupErr("AuthenticationMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.authenticationMicroflow.SetFromDecode(s) } + } + if val, err := raw.LookupErr("AuthenticationTypes"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + items := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { items = append(items, s) } + } + o.authenticationTypes.SetFromDecode(items) + } + } + o.summary.Init(raw) + o.description.Init(raw) + o.replaceIllegalChars.Init(raw) + o.useGeneralization.Init(raw) + if val, err := raw.LookupErr("ODataVersion"); err == nil { + if s, ok := val.StringValueOK(); ok { o.oDataVersion.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// PublishedRestResource +// ──────────────────────────────────────────────────────── + +type PublishedRestResource struct { + element.Base + dataEntity *property.Part[element.Element] + path *property.Primitive[string] + exposedName *property.Primitive[string] + summary *property.Primitive[string] + description *property.Primitive[string] + usePaging *property.Primitive[bool] + pageSize *property.Primitive[int32] + updatable *property.Primitive[bool] + updateMicroflow *property.ByNameRef[element.Element] + insertable *property.Primitive[bool] + deletable *property.Primitive[bool] + updateMode *property.Part[element.Element] + insertMode *property.Part[element.Element] + deleteMode *property.Part[element.Element] + readMode *property.Part[element.Element] + queryOptions *property.Part[element.Element] + queryMicroflow *property.ByNameRef[element.Element] + countMicroflow *property.ByNameRef[element.Element] +} + +// DataEntity returns the value of the dataEntity property. +func (o *PublishedRestResource) DataEntity() element.Element { + return o.dataEntity.Get() +} + +// SetDataEntity sets the value of the dataEntity property. +func (o *PublishedRestResource) SetDataEntity(v element.Element) { + o.dataEntity.Set(v) +} + +// Path returns the value of the path property. +func (o *PublishedRestResource) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *PublishedRestResource) SetPath(v string) { + o.path.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *PublishedRestResource) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *PublishedRestResource) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedRestResource) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedRestResource) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedRestResource) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedRestResource) SetDescription(v string) { + o.description.Set(v) +} + +// UsePaging returns the value of the usePaging property. +func (o *PublishedRestResource) UsePaging() bool { + return o.usePaging.Get() +} + +// SetUsePaging sets the value of the usePaging property. +func (o *PublishedRestResource) SetUsePaging(v bool) { + o.usePaging.Set(v) +} + +// PageSize returns the value of the pageSize property. +func (o *PublishedRestResource) PageSize() int32 { + return o.pageSize.Get() +} + +// SetPageSize sets the value of the pageSize property. +func (o *PublishedRestResource) SetPageSize(v int32) { + o.pageSize.Set(v) +} + +// Updatable returns the value of the updatable property. +func (o *PublishedRestResource) Updatable() bool { + return o.updatable.Get() +} + +// SetUpdatable sets the value of the updatable property. +func (o *PublishedRestResource) SetUpdatable(v bool) { + o.updatable.Set(v) +} + +// UpdateMicroflowQualifiedName returns the value of the updateMicroflow property. +func (o *PublishedRestResource) UpdateMicroflowQualifiedName() string { + return o.updateMicroflow.QualifiedName() +} + +// SetUpdateMicroflowQualifiedName sets the value of the updateMicroflow property. +func (o *PublishedRestResource) SetUpdateMicroflowQualifiedName(v string) { + o.updateMicroflow.SetQualifiedName(v) +} + +// Insertable returns the value of the insertable property. +func (o *PublishedRestResource) Insertable() bool { + return o.insertable.Get() +} + +// SetInsertable sets the value of the insertable property. +func (o *PublishedRestResource) SetInsertable(v bool) { + o.insertable.Set(v) +} + +// Deletable returns the value of the deletable property. +func (o *PublishedRestResource) Deletable() bool { + return o.deletable.Get() +} + +// SetDeletable sets the value of the deletable property. +func (o *PublishedRestResource) SetDeletable(v bool) { + o.deletable.Set(v) +} + +// UpdateMode returns the value of the updateMode property. +func (o *PublishedRestResource) UpdateMode() element.Element { + return o.updateMode.Get() +} + +// SetUpdateMode sets the value of the updateMode property. +func (o *PublishedRestResource) SetUpdateMode(v element.Element) { + o.updateMode.Set(v) +} + +// InsertMode returns the value of the insertMode property. +func (o *PublishedRestResource) InsertMode() element.Element { + return o.insertMode.Get() +} + +// SetInsertMode sets the value of the insertMode property. +func (o *PublishedRestResource) SetInsertMode(v element.Element) { + o.insertMode.Set(v) +} + +// DeleteMode returns the value of the deleteMode property. +func (o *PublishedRestResource) DeleteMode() element.Element { + return o.deleteMode.Get() +} + +// SetDeleteMode sets the value of the deleteMode property. +func (o *PublishedRestResource) SetDeleteMode(v element.Element) { + o.deleteMode.Set(v) +} + +// ReadMode returns the value of the readMode property. +func (o *PublishedRestResource) ReadMode() element.Element { + return o.readMode.Get() +} + +// SetReadMode sets the value of the readMode property. +func (o *PublishedRestResource) SetReadMode(v element.Element) { + o.readMode.Set(v) +} + +// QueryOptions returns the value of the queryOptions property. +func (o *PublishedRestResource) QueryOptions() element.Element { + return o.queryOptions.Get() +} + +// SetQueryOptions sets the value of the queryOptions property. +func (o *PublishedRestResource) SetQueryOptions(v element.Element) { + o.queryOptions.Set(v) +} + +// QueryMicroflowQualifiedName returns the value of the queryMicroflow property. +func (o *PublishedRestResource) QueryMicroflowQualifiedName() string { + return o.queryMicroflow.QualifiedName() +} + +// SetQueryMicroflowQualifiedName sets the value of the queryMicroflow property. +func (o *PublishedRestResource) SetQueryMicroflowQualifiedName(v string) { + o.queryMicroflow.SetQualifiedName(v) +} + +// CountMicroflowQualifiedName returns the value of the countMicroflow property. +func (o *PublishedRestResource) CountMicroflowQualifiedName() string { + return o.countMicroflow.QualifiedName() +} + +// SetCountMicroflowQualifiedName sets the value of the countMicroflow property. +func (o *PublishedRestResource) SetCountMicroflowQualifiedName(v string) { + o.countMicroflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedRestResource) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "DataEntity"); err == nil { + o.dataEntity.SetFromDecode(child) + } + o.path.Init(raw) + o.exposedName.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) + o.usePaging.Init(raw) + o.pageSize.Init(raw) + o.updatable.Init(raw) + if val, err := raw.LookupErr("UpdateMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.updateMicroflow.SetFromDecode(s) } + } + o.insertable.Init(raw) + o.deletable.Init(raw) + if child, err := codec.DecodeChild(raw, "UpdateMode"); err == nil { + o.updateMode.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "InsertMode"); err == nil { + o.insertMode.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DeleteMode"); err == nil { + o.deleteMode.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ReadMode"); err == nil { + o.readMode.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "QueryOptions"); err == nil { + o.queryOptions.SetFromDecode(child) + } + if val, err := raw.LookupErr("QueryMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.queryMicroflow.SetFromDecode(s) } + } + if val, err := raw.LookupErr("CountMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.countMicroflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// PublishedRestService +// ──────────────────────────────────────────────────────── + +type PublishedRestService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + path *property.Primitive[string] + serviceName *property.Primitive[string] + version *property.Primitive[string] + authenticationType *property.Enum[string] + authenticationTypes *property.EnumList[string] + authenticationMicroflow *property.ByNameRef[element.Element] + corsConfiguration *property.Part[element.Element] + allowedRoles *property.ByNameRefList[element.Element] + resources *property.PartList[element.Element] + parameters *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *PublishedRestService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedRestService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedRestService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedRestService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *PublishedRestService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *PublishedRestService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *PublishedRestService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *PublishedRestService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// Path returns the value of the path property. +func (o *PublishedRestService) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *PublishedRestService) SetPath(v string) { + o.path.Set(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *PublishedRestService) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *PublishedRestService) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// Version returns the value of the version property. +func (o *PublishedRestService) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *PublishedRestService) SetVersion(v string) { + o.version.Set(v) +} + +// AuthenticationType returns the value of the authenticationType property. +func (o *PublishedRestService) AuthenticationType() string { + return o.authenticationType.Get() +} + +// SetAuthenticationType sets the value of the authenticationType property. +func (o *PublishedRestService) SetAuthenticationType(v string) { + o.authenticationType.Set(v) +} + +// AuthenticationTypesItems returns the value of the authenticationTypes property. +func (o *PublishedRestService) AuthenticationTypesItems() []string { + return o.authenticationTypes.Items() +} + +// AddAuthenticationTypes appends a child element to the authenticationTypes list. +func (o *PublishedRestService) AddAuthenticationTypes(v string) { + o.authenticationTypes.Append(v) +} + +// AuthenticationMicroflowQualifiedName returns the value of the authenticationMicroflow property. +func (o *PublishedRestService) AuthenticationMicroflowQualifiedName() string { + return o.authenticationMicroflow.QualifiedName() +} + +// SetAuthenticationMicroflowQualifiedName sets the value of the authenticationMicroflow property. +func (o *PublishedRestService) SetAuthenticationMicroflowQualifiedName(v string) { + o.authenticationMicroflow.SetQualifiedName(v) +} + +// CorsConfiguration returns the value of the corsConfiguration property. +func (o *PublishedRestService) CorsConfiguration() element.Element { + return o.corsConfiguration.Get() +} + +// SetCorsConfiguration sets the value of the corsConfiguration property. +func (o *PublishedRestService) SetCorsConfiguration(v element.Element) { + o.corsConfiguration.Set(v) +} + +// AllowedRolesQualifiedNames returns the value of the allowedRoles property. +func (o *PublishedRestService) AllowedRolesQualifiedNames() []string { + return o.allowedRoles.QualifiedNames() +} + +// SetAllowedRolesQualifiedNames sets the value of the allowedRoles property. +func (o *PublishedRestService) SetAllowedRolesQualifiedNames(v []string) { + o.allowedRoles.SetQualifiedNames(v) +} + +// AddAllowedRoles appends a child element to the allowedRoles list. +func (o *PublishedRestService) AddAllowedRoles(v string) { + o.allowedRoles.Append(v) +} + +// ResourcesItems returns the value of the resources property. +func (o *PublishedRestService) ResourcesItems() []element.Element { + return o.resources.Items() +} + +// AddResources appends a child element to the resources list. +func (o *PublishedRestService) AddResources(v element.Element) { + o.resources.Append(v) +} + +// RemoveResources removes the element at the given index from the resources list. +func (o *PublishedRestService) RemoveResources(index int) { + o.resources.Remove(index) +} + +// ParametersItems returns the value of the parameters property. +func (o *PublishedRestService) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *PublishedRestService) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *PublishedRestService) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedRestService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.path.Init(raw) + o.serviceName.Init(raw) + o.version.Init(raw) + if val, err := raw.LookupErr("AuthenticationType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.authenticationType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("AuthenticationTypes"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + items := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { items = append(items, s) } + } + o.authenticationTypes.SetFromDecode(items) + } + } + if val, err := raw.LookupErr("AuthenticationMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.authenticationMicroflow.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "CorsConfiguration"); err == nil { + o.corsConfiguration.SetFromDecode(child) + } + if val, err := raw.LookupErr("AllowedRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.allowedRoles.SetFromDecode(qnames) + } + } + if children, err := codec.DecodeChildren(raw, "Resources"); err == nil { + for _, child := range children { + o.resources.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// PublishedRestServiceOperation +// ──────────────────────────────────────────────────────── + +type PublishedRestServiceOperation struct { + element.Base + summary *property.Primitive[string] + documentation *property.Primitive[string] + path *property.Primitive[string] + deprecated *property.Primitive[bool] + parameters *property.PartList[element.Element] + httpMethod *property.Enum[string] + microflow *property.ByNameRef[element.Element] + exportMapping *property.ByNameRef[element.Element] + importMapping *property.ByNameRef[element.Element] + objectHandlingBackup *property.Enum[string] + commit *property.Enum[string] +} + +// Summary returns the value of the summary property. +func (o *PublishedRestServiceOperation) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedRestServiceOperation) SetSummary(v string) { + o.summary.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedRestServiceOperation) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedRestServiceOperation) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Path returns the value of the path property. +func (o *PublishedRestServiceOperation) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *PublishedRestServiceOperation) SetPath(v string) { + o.path.Set(v) +} + +// Deprecated returns the value of the deprecated property. +func (o *PublishedRestServiceOperation) Deprecated() bool { + return o.deprecated.Get() +} + +// SetDeprecated sets the value of the deprecated property. +func (o *PublishedRestServiceOperation) SetDeprecated(v bool) { + o.deprecated.Set(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *PublishedRestServiceOperation) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *PublishedRestServiceOperation) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *PublishedRestServiceOperation) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// HttpMethod returns the value of the httpMethod property. +func (o *PublishedRestServiceOperation) HttpMethod() string { + return o.httpMethod.Get() +} + +// SetHttpMethod sets the value of the httpMethod property. +func (o *PublishedRestServiceOperation) SetHttpMethod(v string) { + o.httpMethod.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *PublishedRestServiceOperation) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *PublishedRestServiceOperation) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ExportMappingQualifiedName returns the value of the exportMapping property. +func (o *PublishedRestServiceOperation) ExportMappingQualifiedName() string { + return o.exportMapping.QualifiedName() +} + +// SetExportMappingQualifiedName sets the value of the exportMapping property. +func (o *PublishedRestServiceOperation) SetExportMappingQualifiedName(v string) { + o.exportMapping.SetQualifiedName(v) +} + +// ImportMappingQualifiedName returns the value of the importMapping property. +func (o *PublishedRestServiceOperation) ImportMappingQualifiedName() string { + return o.importMapping.QualifiedName() +} + +// SetImportMappingQualifiedName sets the value of the importMapping property. +func (o *PublishedRestServiceOperation) SetImportMappingQualifiedName(v string) { + o.importMapping.SetQualifiedName(v) +} + +// ObjectHandlingBackup returns the value of the objectHandlingBackup property. +func (o *PublishedRestServiceOperation) ObjectHandlingBackup() string { + return o.objectHandlingBackup.Get() +} + +// SetObjectHandlingBackup sets the value of the objectHandlingBackup property. +func (o *PublishedRestServiceOperation) SetObjectHandlingBackup(v string) { + o.objectHandlingBackup.Set(v) +} + +// Commit returns the value of the commit property. +func (o *PublishedRestServiceOperation) Commit() string { + return o.commit.Get() +} + +// SetCommit sets the value of the commit property. +func (o *PublishedRestServiceOperation) SetCommit(v string) { + o.commit.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedRestServiceOperation) InitFromRaw(raw bson.Raw) { + o.summary.Init(raw) + o.documentation.Init(raw) + o.path.Init(raw) + o.deprecated.Init(raw) + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("HttpMethod"); err == nil { + if s, ok := val.StringValueOK(); ok { o.httpMethod.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ExportMapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportMapping.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ImportMapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.importMapping.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ObjectHandlingBackup"); err == nil { + if s, ok := val.StringValueOK(); ok { o.objectHandlingBackup.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Commit"); err == nil { + if s, ok := val.StringValueOK(); ok { o.commit.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// PublishedRestServiceResource +// ──────────────────────────────────────────────────────── + +type PublishedRestServiceResource struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + operations *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *PublishedRestServiceResource) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedRestServiceResource) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedRestServiceResource) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedRestServiceResource) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// OperationsItems returns the value of the operations property. +func (o *PublishedRestServiceResource) OperationsItems() []element.Element { + return o.operations.Items() +} + +// AddOperations appends a child element to the operations list. +func (o *PublishedRestServiceResource) AddOperations(v element.Element) { + o.operations.Append(v) +} + +// RemoveOperations removes the element at the given index from the operations list. +func (o *PublishedRestServiceResource) RemoveOperations(index int) { + o.operations.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedRestServiceResource) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + if children, err := codec.DecodeChildren(raw, "Operations"); err == nil { + for _, child := range children { + o.operations.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// QueryOptions +// ──────────────────────────────────────────────────────── + +type QueryOptions struct { + element.Base + countable *property.Primitive[bool] + topSupported *property.Primitive[bool] + skipSupported *property.Primitive[bool] +} + +// Countable returns the value of the countable property. +func (o *QueryOptions) Countable() bool { + return o.countable.Get() +} + +// SetCountable sets the value of the countable property. +func (o *QueryOptions) SetCountable(v bool) { + o.countable.Set(v) +} + +// TopSupported returns the value of the topSupported property. +func (o *QueryOptions) TopSupported() bool { + return o.topSupported.Get() +} + +// SetTopSupported sets the value of the topSupported property. +func (o *QueryOptions) SetTopSupported(v bool) { + o.topSupported.Set(v) +} + +// SkipSupported returns the value of the skipSupported property. +func (o *QueryOptions) SkipSupported() bool { + return o.skipSupported.Get() +} + +// SetSkipSupported sets the value of the skipSupported property. +func (o *QueryOptions) SetSkipSupported(v bool) { + o.skipSupported.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueryOptions) InitFromRaw(raw bson.Raw) { + o.countable.Init(raw) + o.topSupported.Init(raw) + o.skipSupported.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// QueryParameter +// ──────────────────────────────────────────────────────── + +type QueryParameter struct { + element.Base + name *property.Primitive[string] + testValue *property.Primitive[string] + parameterUsage *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *QueryParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *QueryParameter) SetName(v string) { + o.name.Set(v) +} + +// TestValue returns the value of the testValue property. +func (o *QueryParameter) TestValue() string { + return o.testValue.Get() +} + +// SetTestValue sets the value of the testValue property. +func (o *QueryParameter) SetTestValue(v string) { + o.testValue.Set(v) +} + +// ParameterUsage returns the value of the parameterUsage property. +func (o *QueryParameter) ParameterUsage() element.Element { + return o.parameterUsage.Get() +} + +// SetParameterUsage sets the value of the parameterUsage property. +func (o *QueryParameter) SetParameterUsage(v element.Element) { + o.parameterUsage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *QueryParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.testValue.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterUsage"); err == nil { + o.parameterUsage.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ReadSource +// ──────────────────────────────────────────────────────── + +type ReadSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ReadSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// RequiredQueryParameterUsage +// ──────────────────────────────────────────────────────── + +type RequiredQueryParameterUsage struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RequiredQueryParameterUsage) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// RestOperation +// ──────────────────────────────────────────────────────── + +type RestOperation struct { + element.Base + name *property.Primitive[string] + path *property.Part[element.Element] + method *property.Part[element.Element] + timeout *property.Primitive[int32] + headers *property.PartList[element.Element] + parameters *property.PartList[element.Element] + queryParameters *property.PartList[element.Element] + responseHandling *property.Part[element.Element] + tags *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *RestOperation) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RestOperation) SetName(v string) { + o.name.Set(v) +} + +// Path returns the value of the path property. +func (o *RestOperation) Path() element.Element { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *RestOperation) SetPath(v element.Element) { + o.path.Set(v) +} + +// Method returns the value of the method property. +func (o *RestOperation) Method() element.Element { + return o.method.Get() +} + +// SetMethod sets the value of the method property. +func (o *RestOperation) SetMethod(v element.Element) { + o.method.Set(v) +} + +// Timeout returns the value of the timeout property. +func (o *RestOperation) Timeout() int32 { + return o.timeout.Get() +} + +// SetTimeout sets the value of the timeout property. +func (o *RestOperation) SetTimeout(v int32) { + o.timeout.Set(v) +} + +// HeadersItems returns the value of the headers property. +func (o *RestOperation) HeadersItems() []element.Element { + return o.headers.Items() +} + +// AddHeaders appends a child element to the headers list. +func (o *RestOperation) AddHeaders(v element.Element) { + o.headers.Append(v) +} + +// RemoveHeaders removes the element at the given index from the headers list. +func (o *RestOperation) RemoveHeaders(index int) { + o.headers.Remove(index) +} + +// ParametersItems returns the value of the parameters property. +func (o *RestOperation) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *RestOperation) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *RestOperation) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// QueryParametersItems returns the value of the queryParameters property. +func (o *RestOperation) QueryParametersItems() []element.Element { + return o.queryParameters.Items() +} + +// AddQueryParameters appends a child element to the queryParameters list. +func (o *RestOperation) AddQueryParameters(v element.Element) { + o.queryParameters.Append(v) +} + +// RemoveQueryParameters removes the element at the given index from the queryParameters list. +func (o *RestOperation) RemoveQueryParameters(index int) { + o.queryParameters.Remove(index) +} + +// ResponseHandling returns the value of the responseHandling property. +func (o *RestOperation) ResponseHandling() element.Element { + return o.responseHandling.Get() +} + +// SetResponseHandling sets the value of the responseHandling property. +func (o *RestOperation) SetResponseHandling(v element.Element) { + o.responseHandling.Set(v) +} + +// Tags returns the value of the tags property. +func (o *RestOperation) Tags() string { + return o.tags.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestOperation) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Path"); err == nil { + o.path.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Method"); err == nil { + o.method.SetFromDecode(child) + } + o.timeout.Init(raw) + if children, err := codec.DecodeChildren(raw, "Headers"); err == nil { + for _, child := range children { + o.headers.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "QueryParameters"); err == nil { + for _, child := range children { + o.queryParameters.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "ResponseHandling"); err == nil { + o.responseHandling.SetFromDecode(child) + } + o.tags.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RestOperationMethod +// ──────────────────────────────────────────────────────── + +type RestOperationMethod struct { + element.Base + httpMethod *property.Enum[string] +} + +// HttpMethod returns the value of the httpMethod property. +func (o *RestOperationMethod) HttpMethod() string { + return o.httpMethod.Get() +} + +// SetHttpMethod sets the value of the httpMethod property. +func (o *RestOperationMethod) SetHttpMethod(v string) { + o.httpMethod.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestOperationMethod) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("HttpMethod"); err == nil { + if s, ok := val.StringValueOK(); ok { o.httpMethod.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// RestOperationMethodWithBody +// ──────────────────────────────────────────────────────── + +type RestOperationMethodWithBody struct { + element.Base + httpMethod *property.Enum[string] + body *property.Part[element.Element] +} + +// HttpMethod returns the value of the httpMethod property. +func (o *RestOperationMethodWithBody) HttpMethod() string { + return o.httpMethod.Get() +} + +// SetHttpMethod sets the value of the httpMethod property. +func (o *RestOperationMethodWithBody) SetHttpMethod(v string) { + o.httpMethod.Set(v) +} + +// Body returns the value of the body property. +func (o *RestOperationMethodWithBody) Body() element.Element { + return o.body.Get() +} + +// SetBody sets the value of the body property. +func (o *RestOperationMethodWithBody) SetBody(v element.Element) { + o.body.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestOperationMethodWithBody) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("HttpMethod"); err == nil { + if s, ok := val.StringValueOK(); ok { o.httpMethod.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Body"); err == nil { + o.body.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// RestOperationMethodWithoutBody +// ──────────────────────────────────────────────────────── + +type RestOperationMethodWithoutBody struct { + element.Base + httpMethod *property.Enum[string] +} + +// HttpMethod returns the value of the httpMethod property. +func (o *RestOperationMethodWithoutBody) HttpMethod() string { + return o.httpMethod.Get() +} + +// SetHttpMethod sets the value of the httpMethod property. +func (o *RestOperationMethodWithoutBody) SetHttpMethod(v string) { + o.httpMethod.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestOperationMethodWithoutBody) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("HttpMethod"); err == nil { + if s, ok := val.StringValueOK(); ok { o.httpMethod.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// RestOperationParameter +// ──────────────────────────────────────────────────────── + +type RestOperationParameter struct { + element.Base + name *property.Primitive[string] + microflowParameter *property.ByNameRef[element.Element] + propType *property.Part[element.Element] + parameterType *property.Enum[string] + description *property.Primitive[string] + dataType *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *RestOperationParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RestOperationParameter) SetName(v string) { + o.name.Set(v) +} + +// MicroflowParameterQualifiedName returns the value of the microflowParameter property. +func (o *RestOperationParameter) MicroflowParameterQualifiedName() string { + return o.microflowParameter.QualifiedName() +} + +// SetMicroflowParameterQualifiedName sets the value of the microflowParameter property. +func (o *RestOperationParameter) SetMicroflowParameterQualifiedName(v string) { + o.microflowParameter.SetQualifiedName(v) +} + +// Type returns the value of the type property. +func (o *RestOperationParameter) Type() element.Element { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *RestOperationParameter) SetType(v element.Element) { + o.propType.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *RestOperationParameter) ParameterType() string { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *RestOperationParameter) SetParameterType(v string) { + o.parameterType.Set(v) +} + +// Description returns the value of the description property. +func (o *RestOperationParameter) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *RestOperationParameter) SetDescription(v string) { + o.description.Set(v) +} + +// DataType returns the value of the dataType property. +func (o *RestOperationParameter) DataType() string { + return o.dataType.Get() +} + +// SetDataType sets the value of the dataType property. +func (o *RestOperationParameter) SetDataType(v string) { + o.dataType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestOperationParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if val, err := raw.LookupErr("MicroflowParameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflowParameter.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Type"); err == nil { + o.propType.SetFromDecode(child) + } + if val, err := raw.LookupErr("ParameterType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameterType.SetFromDecode(s) } + } + o.description.Init(raw) + o.dataType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RestParameter +// ──────────────────────────────────────────────────────── + +type RestParameter struct { + element.Base + name *property.Primitive[string] + dataType *property.Part[element.Element] + testValue *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *RestParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RestParameter) SetName(v string) { + o.name.Set(v) +} + +// DataType returns the value of the dataType property. +func (o *RestParameter) DataType() element.Element { + return o.dataType.Get() +} + +// SetDataType sets the value of the dataType property. +func (o *RestParameter) SetDataType(v element.Element) { + o.dataType.Set(v) +} + +// TestValue returns the value of the testValue property. +func (o *RestParameter) TestValue() element.Element { + return o.testValue.Get() +} + +// SetTestValue sets the value of the testValue property. +func (o *RestParameter) SetTestValue(v element.Element) { + o.testValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "DataType"); err == nil { + o.dataType.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TestValue"); err == nil { + o.testValue.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ServiceFeed +// ──────────────────────────────────────────────────────── + +type ServiceFeed struct { + element.Base + xml *property.Primitive[string] + json *property.Primitive[string] +} + +// Xml returns the value of the xml property. +func (o *ServiceFeed) Xml() string { + return o.xml.Get() +} + +// SetXml sets the value of the xml property. +func (o *ServiceFeed) SetXml(v string) { + o.xml.Set(v) +} + +// Json returns the value of the json property. +func (o *ServiceFeed) Json() string { + return o.json.Get() +} + +// SetJson sets the value of the json property. +func (o *ServiceFeed) SetJson(v string) { + o.json.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ServiceFeed) InitFromRaw(raw bson.Raw) { + o.xml.Init(raw) + o.json.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// StringBody +// ──────────────────────────────────────────────────────── + +type StringBody struct { + element.Base + value *property.Primitive[string] + valueTemplate *property.Part[element.Element] +} + +// Value returns the value of the value property. +func (o *StringBody) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *StringBody) SetValue(v string) { + o.value.Set(v) +} + +// ValueTemplate returns the value of the valueTemplate property. +func (o *StringBody) ValueTemplate() element.Element { + return o.valueTemplate.Get() +} + +// SetValueTemplate sets the value of the valueTemplate property. +func (o *StringBody) SetValueTemplate(v element.Element) { + o.valueTemplate.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringBody) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) + if child, err := codec.DecodeChild(raw, "ValueTemplate"); err == nil { + o.valueTemplate.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// StringValue +// ──────────────────────────────────────────────────────── + +type StringValue struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *StringValue) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *StringValue) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringValue) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ValueTemplate +// ──────────────────────────────────────────────────────── + +type ValueTemplate struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *ValueTemplate) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *ValueTemplate) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ValueTemplate) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RestCallOperation +// ──────────────────────────────────────────────────────── + +type RestCallOperation struct { + element.Base + httpMethod *property.Primitive[string] + url *property.Primitive[string] + timeoutExpression *property.Primitive[string] + proxyType *property.Primitive[string] + parameters *property.PartList[element.Element] + queryParameters *property.PartList[element.Element] + headers *property.PartList[element.Element] +} + +// HttpMethod returns the value of the httpMethod property. +func (o *RestCallOperation) HttpMethod() string { + return o.httpMethod.Get() +} + +// SetHttpMethod sets the value of the httpMethod property. +func (o *RestCallOperation) SetHttpMethod(v string) { + o.httpMethod.Set(v) +} + +// Url returns the value of the url property. +func (o *RestCallOperation) Url() string { + return o.url.Get() +} + +// SetUrl sets the value of the url property. +func (o *RestCallOperation) SetUrl(v string) { + o.url.Set(v) +} + +// TimeoutExpression returns the value of the timeoutExpression property. +func (o *RestCallOperation) TimeoutExpression() string { + return o.timeoutExpression.Get() +} + +// SetTimeoutExpression sets the value of the timeoutExpression property. +func (o *RestCallOperation) SetTimeoutExpression(v string) { + o.timeoutExpression.Set(v) +} + +// ProxyType returns the value of the proxyType property. +func (o *RestCallOperation) ProxyType() string { + return o.proxyType.Get() +} + +// SetProxyType sets the value of the proxyType property. +func (o *RestCallOperation) SetProxyType(v string) { + o.proxyType.Set(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *RestCallOperation) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *RestCallOperation) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *RestCallOperation) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// QueryParametersItems returns the value of the queryParameters property. +func (o *RestCallOperation) QueryParametersItems() []element.Element { + return o.queryParameters.Items() +} + +// AddQueryParameters appends a child element to the queryParameters list. +func (o *RestCallOperation) AddQueryParameters(v element.Element) { + o.queryParameters.Append(v) +} + +// RemoveQueryParameters removes the element at the given index from the queryParameters list. +func (o *RestCallOperation) RemoveQueryParameters(index int) { + o.queryParameters.Remove(index) +} + +// HeadersItems returns the value of the headers property. +func (o *RestCallOperation) HeadersItems() []element.Element { + return o.headers.Items() +} + +// AddHeaders appends a child element to the headers list. +func (o *RestCallOperation) AddHeaders(v element.Element) { + o.headers.Append(v) +} + +// RemoveHeaders removes the element at the given index from the headers list. +func (o *RestCallOperation) RemoveHeaders(index int) { + o.headers.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestCallOperation) InitFromRaw(raw bson.Raw) { + o.httpMethod.Init(raw) + o.url.Init(raw) + o.timeoutExpression.Init(raw) + o.proxyType.Init(raw) + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "QueryParameters"); err == nil { + for _, child := range children { + o.queryParameters.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Headers"); err == nil { + for _, child := range children { + o.headers.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// RestCallParameter +// ──────────────────────────────────────────────────────── + +type RestCallParameter struct { + element.Base + name *property.Primitive[string] + propType *property.Primitive[string] + value *property.Primitive[string] + testValue *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *RestCallParameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RestCallParameter) SetName(v string) { + o.name.Set(v) +} + +// Type returns the value of the type property. +func (o *RestCallParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *RestCallParameter) SetType(v string) { + o.propType.Set(v) +} + +// Value returns the value of the value property. +func (o *RestCallParameter) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *RestCallParameter) SetValue(v string) { + o.value.Set(v) +} + +// TestValue returns the value of the testValue property. +func (o *RestCallParameter) TestValue() string { + return o.testValue.Get() +} + +// SetTestValue sets the value of the testValue property. +func (o *RestCallParameter) SetTestValue(v string) { + o.testValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestCallParameter) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.propType.Init(raw) + o.value.Init(raw) + o.testValue.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RestCallHeader +// ──────────────────────────────────────────────────────── + +type RestCallHeader struct { + element.Base + name *property.Primitive[string] + value *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *RestCallHeader) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RestCallHeader) SetName(v string) { + o.name.Set(v) +} + +// Value returns the value of the value property. +func (o *RestCallHeader) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *RestCallHeader) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RestCallHeader) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedRestOperation +// ──────────────────────────────────────────────────────── + +type PublishedRestOperation struct { + element.Base + path *property.Primitive[string] + httpMethod *property.Primitive[string] + deprecated *property.Primitive[bool] + summary *property.Primitive[string] + description *property.Primitive[string] + microflow *property.ByNameRef[element.Element] + importMapping *property.ByNameRef[element.Element] + exportMapping *property.ByNameRef[element.Element] + objectHandlingBackup *property.Primitive[string] + commit *property.Primitive[string] +} + +// Path returns the value of the path property. +func (o *PublishedRestOperation) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *PublishedRestOperation) SetPath(v string) { + o.path.Set(v) +} + +// HttpMethod returns the value of the httpMethod property. +func (o *PublishedRestOperation) HttpMethod() string { + return o.httpMethod.Get() +} + +// SetHttpMethod sets the value of the httpMethod property. +func (o *PublishedRestOperation) SetHttpMethod(v string) { + o.httpMethod.Set(v) +} + +// Deprecated returns the value of the deprecated property. +func (o *PublishedRestOperation) Deprecated() bool { + return o.deprecated.Get() +} + +// SetDeprecated sets the value of the deprecated property. +func (o *PublishedRestOperation) SetDeprecated(v bool) { + o.deprecated.Set(v) +} + +// Summary returns the value of the summary property. +func (o *PublishedRestOperation) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *PublishedRestOperation) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *PublishedRestOperation) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedRestOperation) SetDescription(v string) { + o.description.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *PublishedRestOperation) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *PublishedRestOperation) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ImportMappingQualifiedName returns the value of the importMapping property. +func (o *PublishedRestOperation) ImportMappingQualifiedName() string { + return o.importMapping.QualifiedName() +} + +// SetImportMappingQualifiedName sets the value of the importMapping property. +func (o *PublishedRestOperation) SetImportMappingQualifiedName(v string) { + o.importMapping.SetQualifiedName(v) +} + +// ExportMappingQualifiedName returns the value of the exportMapping property. +func (o *PublishedRestOperation) ExportMappingQualifiedName() string { + return o.exportMapping.QualifiedName() +} + +// SetExportMappingQualifiedName sets the value of the exportMapping property. +func (o *PublishedRestOperation) SetExportMappingQualifiedName(v string) { + o.exportMapping.SetQualifiedName(v) +} + +// ObjectHandlingBackup returns the value of the objectHandlingBackup property. +func (o *PublishedRestOperation) ObjectHandlingBackup() string { + return o.objectHandlingBackup.Get() +} + +// SetObjectHandlingBackup sets the value of the objectHandlingBackup property. +func (o *PublishedRestOperation) SetObjectHandlingBackup(v string) { + o.objectHandlingBackup.Set(v) +} + +// Commit returns the value of the commit property. +func (o *PublishedRestOperation) Commit() string { + return o.commit.Get() +} + +// SetCommit sets the value of the commit property. +func (o *PublishedRestOperation) SetCommit(v string) { + o.commit.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedRestOperation) InitFromRaw(raw bson.Raw) { + o.path.Init(raw) + o.httpMethod.Init(raw) + o.deprecated.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ImportMapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.importMapping.SetFromDecode(s) } + } + if val, err := raw.LookupErr("ExportMapping"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportMapping.SetFromDecode(s) } + } + o.objectHandlingBackup.Init(raw) + o.commit.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initBasicAuthenticationScheme creates a BasicAuthenticationScheme with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBasicAuthenticationScheme() *BasicAuthenticationScheme { + o := &BasicAuthenticationScheme{} + o.SetTypeName("Rest$BasicAuthentication") + o.username = property.NewPart[element.Element]("Username") + o.username.Bind(&o.Base, 0) + o.password = property.NewPart[element.Element]("Password") + o.password.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.username, o.password, }) + return o +} + +// NewBasicAuthenticationScheme creates a new BasicAuthenticationScheme for user code. Marked dirty (bit 63 = new element). +func NewBasicAuthenticationScheme() *BasicAuthenticationScheme { + o := initBasicAuthenticationScheme() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCallMicroflowToChange creates a CallMicroflowToChange with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCallMicroflowToChange() *CallMicroflowToChange { + o := &CallMicroflowToChange{} + o.SetTypeName("Rest$CallMicroflowToChange") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow, }) + return o +} + +// NewCallMicroflowToChange creates a new CallMicroflowToChange for user code. Marked dirty (bit 63 = new element). +func NewCallMicroflowToChange() *CallMicroflowToChange { + o := initCallMicroflowToChange() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCallMicroflowToRead creates a CallMicroflowToRead with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCallMicroflowToRead() *CallMicroflowToRead { + o := &CallMicroflowToRead{} + o.SetTypeName("Rest$CallMicroflowToRead") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow, }) + return o +} + +// NewCallMicroflowToRead creates a new CallMicroflowToRead for user code. Marked dirty (bit 63 = new element). +func NewCallMicroflowToRead() *CallMicroflowToRead { + o := initCallMicroflowToRead() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initChangeNotSupported creates a ChangeNotSupported with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initChangeNotSupported() *ChangeNotSupported { + o := &ChangeNotSupported{} + o.SetTypeName("Rest$ChangeNotSupported") + o.SetProperties([]element.Property{}) + return o +} + +// NewChangeNotSupported creates a new ChangeNotSupported for user code. Marked dirty (bit 63 = new element). +func NewChangeNotSupported() *ChangeNotSupported { + o := initChangeNotSupported() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initChangeSource creates a ChangeSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initChangeSource() *ChangeSource { + o := &ChangeSource{} + o.SetTypeName("Rest$ChangeSource") + o.SetProperties([]element.Property{}) + return o +} + +// NewChangeSource creates a new ChangeSource for user code. Marked dirty (bit 63 = new element). +func NewChangeSource() *ChangeSource { + o := initChangeSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConstantValue creates a ConstantValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConstantValue() *ConstantValue { + o := &ConstantValue{} + o.SetTypeName("Rest$ConstantValue") + o.value = property.NewByNameRef[element.Element]("Value", "Constants$Constant") + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value, }) + return o +} + +// NewConstantValue creates a new ConstantValue for user code. Marked dirty (bit 63 = new element). +func NewConstantValue() *ConstantValue { + o := initConstantValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConsumedODataService creates a ConsumedODataService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConsumedODataService() *ConsumedODataService { + o := &ConsumedODataService{} + o.SetTypeName("Rest$ConsumedODataService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 4) + o.catalogUrl = property.NewPrimitive[string]("CatalogUrl", property.DecodeString) + o.catalogUrl.Bind(&o.Base, 5) + o.icon = property.NewPrimitive[string]("Icon", property.DecodeString) + o.icon.Bind(&o.Base, 6) + o.metadata = property.NewPrimitive[string]("Metadata", property.DecodeString) + o.metadata.Bind(&o.Base, 7) + o.metadataUrl = property.NewPrimitive[string]("MetadataUrl", property.DecodeString) + o.metadataUrl.Bind(&o.Base, 8) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 9) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 10) + o.endpointId = property.NewPrimitive[string]("EndpointId", property.DecodeString) + o.endpointId.Bind(&o.Base, 11) + o.minimumMxVersion = property.NewPrimitive[string]("MinimumMxVersion", property.DecodeString) + o.minimumMxVersion.Bind(&o.Base, 12) + o.recommendedMxVersion = property.NewPrimitive[string]("RecommendedMxVersion", property.DecodeString) + o.recommendedMxVersion.Bind(&o.Base, 13) + o.applicationId = property.NewPrimitive[string]("ApplicationId", property.DecodeString) + o.applicationId.Bind(&o.Base, 14) + o.environmentType = property.NewEnum[string]("EnvironmentType") + o.environmentType.Bind(&o.Base, 15) + o.metadataHash = property.NewPrimitive[string]("MetadataHash", property.DecodeString) + o.metadataHash.Bind(&o.Base, 16) + o.validated = property.NewPrimitive[bool]("Validated", property.DecodeBool) + o.validated.Bind(&o.Base, 17) + o.validatedEntities = property.NewPrimitive[string]("ValidatedEntities", property.DecodeString) + o.validatedEntities.Bind(&o.Base, 18) + o.metadataReferences = property.NewPartList[element.Element]("MetadataReferences") + o.metadataReferences.Bind(&o.Base, 19) + o.proxyType = property.NewEnum[string]("ProxyType") + o.proxyType.Bind(&o.Base, 20) + o.proxyHost = property.NewByNameRef[element.Element]("ProxyHost", "Constants$Constant") + o.proxyHost.Bind(&o.Base, 21) + o.proxyPort = property.NewByNameRef[element.Element]("ProxyPort", "Constants$Constant") + o.proxyPort.Bind(&o.Base, 22) + o.proxyUsername = property.NewByNameRef[element.Element]("ProxyUsername", "Constants$Constant") + o.proxyUsername.Bind(&o.Base, 23) + o.proxyPassword = property.NewByNameRef[element.Element]("ProxyPassword", "Constants$Constant") + o.proxyPassword.Bind(&o.Base, 24) + o.httpConfiguration = property.NewPart[element.Element]("HttpConfiguration") + o.httpConfiguration.Bind(&o.Base, 25) + o.headersMicroflow = property.NewByNameRef[element.Element]("HeadersMicroflow", "Microflows$Microflow") + o.headersMicroflow.Bind(&o.Base, 26) + o.configurationMicroflow = property.NewByNameRef[element.Element]("ConfigurationMicroflow", "Microflows$Microflow") + o.configurationMicroflow.Bind(&o.Base, 27) + o.timeoutModel = property.NewPart[element.Element]("TimeoutModel") + o.timeoutModel.Bind(&o.Base, 28) + o.timeoutExpression = property.NewPrimitive[string]("TimeoutExpression", property.DecodeString) + o.timeoutExpression.Bind(&o.Base, 29) + o.oDataVersion = property.NewEnum[string]("ODataVersion") + o.oDataVersion.Bind(&o.Base, 30) + o.versionApiMockResults = property.NewPrimitive[string]("VersionApiMockResults", property.DecodeString) + o.versionApiMockResults.Bind(&o.Base, 31) + o.serviceId = property.NewPrimitive[string]("ServiceId", property.DecodeString) + o.serviceId.Bind(&o.Base, 32) + o.lastUpdated = property.NewPrimitive[string]("LastUpdated", property.DecodeString) + o.lastUpdated.Bind(&o.Base, 33) + o.useQuerySegment = property.NewPrimitive[bool]("UseQuerySegment", property.DecodeBool) + o.useQuerySegment.Bind(&o.Base, 34) + o.errorHandlingMicroflow = property.NewByNameRef[element.Element]("ErrorHandlingMicroflow", "Microflows$Microflow") + o.errorHandlingMicroflow.Bind(&o.Base, 35) + o.serviceUrl = property.NewPrimitive[string]("ServiceUrl", property.DecodeString) + o.serviceUrl.Bind(&o.Base, 36) + o.httpUsername = property.NewPrimitive[string]("HttpUsername", property.DecodeString) + o.httpUsername.Bind(&o.Base, 37) + o.httpPassword = property.NewPrimitive[string]("HttpPassword", property.DecodeString) + o.httpPassword.Bind(&o.Base, 38) + o.useAuthentication = property.NewPrimitive[bool]("UseAuthentication", property.DecodeBool) + o.useAuthentication.Bind(&o.Base, 39) + o.clientCertificate = property.NewPrimitive[string]("ClientCertificate", property.DecodeString) + o.clientCertificate.Bind(&o.Base, 40) + o.headers = property.NewPartList[element.Element]("Headers") + o.headers.Bind(&o.Base, 41) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.description, o.catalogUrl, o.icon, o.metadata, o.metadataUrl, o.serviceName, o.version, o.endpointId, o.minimumMxVersion, o.recommendedMxVersion, o.applicationId, o.environmentType, o.metadataHash, o.validated, o.validatedEntities, o.metadataReferences, o.proxyType, o.proxyHost, o.proxyPort, o.proxyUsername, o.proxyPassword, o.httpConfiguration, o.headersMicroflow, o.configurationMicroflow, o.timeoutModel, o.timeoutExpression, o.oDataVersion, o.versionApiMockResults, o.serviceId, o.lastUpdated, o.useQuerySegment, o.errorHandlingMicroflow, o.serviceUrl, o.httpUsername, o.httpPassword, o.useAuthentication, o.clientCertificate, o.headers, }) + return o +} + +// NewConsumedODataService creates a new ConsumedODataService for user code. Marked dirty (bit 63 = new element). +func NewConsumedODataService() *ConsumedODataService { + o := initConsumedODataService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConsumedRestService creates a ConsumedRestService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConsumedRestService() *ConsumedRestService { + o := &ConsumedRestService{} + o.SetTypeName("Rest$ConsumedRestService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.openApiFile = property.NewPart[element.Element]("OpenApiFile") + o.openApiFile.Bind(&o.Base, 4) + o.baseUrl = property.NewPart[element.Element]("BaseUrl") + o.baseUrl.Bind(&o.Base, 5) + o.authenticationScheme = property.NewPart[element.Element]("AuthenticationScheme") + o.authenticationScheme.Bind(&o.Base, 6) + o.operations = property.NewPartList[element.Element]("Operations") + o.operations.Bind(&o.Base, 7) + o.baseUrlParameter = property.NewPart[element.Element]("BaseUrlParameter") + o.baseUrlParameter.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.openApiFile, o.baseUrl, o.authenticationScheme, o.operations, o.baseUrlParameter, }) + return o +} + +// NewConsumedRestService creates a new ConsumedRestService for user code. Marked dirty (bit 63 = new element). +func NewConsumedRestService() *ConsumedRestService { + o := initConsumedRestService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCorsConfiguration creates a CorsConfiguration with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCorsConfiguration() *CorsConfiguration { + o := &CorsConfiguration{} + o.SetTypeName("Rest$CorsConfiguration") + o.allowedOrigins = property.NewByNameRef[element.Element]("AllowedOrigins", "Constants$Constant") + o.allowedOrigins.Bind(&o.Base, 0) + o.allowAuthentication = property.NewPrimitive[bool]("AllowAuthentication", property.DecodeBool) + o.allowAuthentication.Bind(&o.Base, 1) + o.maxAge = property.NewByNameRef[element.Element]("MaxAge", "Constants$Constant") + o.maxAge.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.allowedOrigins, o.allowAuthentication, o.maxAge, }) + return o +} + +// NewCorsConfiguration creates a new CorsConfiguration for user code. Marked dirty (bit 63 = new element). +func NewCorsConfiguration() *CorsConfiguration { + o := initCorsConfiguration() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initHeaderWithValueTemplate creates a HeaderWithValueTemplate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initHeaderWithValueTemplate() *HeaderWithValueTemplate { + o := &HeaderWithValueTemplate{} + o.SetTypeName("Rest$HeaderWithValueTemplate") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.value = property.NewPart[element.Element]("Value") + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.value, }) + return o +} + +// NewHeaderWithValueTemplate creates a new HeaderWithValueTemplate for user code. Marked dirty (bit 63 = new element). +func NewHeaderWithValueTemplate() *HeaderWithValueTemplate { + o := initHeaderWithValueTemplate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImplicitMappingBody creates a ImplicitMappingBody with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImplicitMappingBody() *ImplicitMappingBody { + o := &ImplicitMappingBody{} + o.SetTypeName("Rest$ImplicitMappingBody") + o.rootMappingElement = property.NewPart[element.Element]("RootMappingElement") + o.rootMappingElement.Bind(&o.Base, 0) + o.testValue = property.NewPart[element.Element]("TestValue") + o.testValue.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.rootMappingElement, o.testValue, }) + return o +} + +// NewImplicitMappingBody creates a new ImplicitMappingBody for user code. Marked dirty (bit 63 = new element). +func NewImplicitMappingBody() *ImplicitMappingBody { + o := initImplicitMappingBody() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImplicitMappingResponseHandling creates a ImplicitMappingResponseHandling with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImplicitMappingResponseHandling() *ImplicitMappingResponseHandling { + o := &ImplicitMappingResponseHandling{} + o.SetTypeName("Rest$ImplicitMappingResponseHandling") + o.statusCode = property.NewPrimitive[int32]("StatusCode", property.DecodeInt32) + o.statusCode.Bind(&o.Base, 0) + o.contentType = property.NewPrimitive[string]("ContentType", property.DecodeString) + o.contentType.Bind(&o.Base, 1) + o.rootMappingElement = property.NewPart[element.Element]("RootMappingElement") + o.rootMappingElement.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.statusCode, o.contentType, o.rootMappingElement, }) + return o +} + +// NewImplicitMappingResponseHandling creates a new ImplicitMappingResponseHandling for user code. Marked dirty (bit 63 = new element). +func NewImplicitMappingResponseHandling() *ImplicitMappingResponseHandling { + o := initImplicitMappingResponseHandling() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJsonBody creates a JsonBody with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJsonBody() *JsonBody { + o := &JsonBody{} + o.SetTypeName("Rest$JsonBody") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value, }) + return o +} + +// NewJsonBody creates a new JsonBody for user code. Marked dirty (bit 63 = new element). +func NewJsonBody() *JsonBody { + o := initJsonBody() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMetadataReference creates a MetadataReference with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMetadataReference() *MetadataReference { + o := &MetadataReference{} + o.SetTypeName("Rest$MetadataReference") + o.uri = property.NewPrimitive[string]("Uri", property.DecodeString) + o.uri.Bind(&o.Base, 0) + o.metadata = property.NewPrimitive[string]("Metadata", property.DecodeString) + o.metadata.Bind(&o.Base, 1) + o.metadataReferences = property.NewPartList[element.Element]("MetadataReferences") + o.metadataReferences.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.uri, o.metadata, o.metadataReferences, }) + return o +} + +// NewMetadataReference creates a new MetadataReference for user code. Marked dirty (bit 63 = new element). +func NewMetadataReference() *MetadataReference { + o := initMetadataReference() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNoResponseHandling creates a NoResponseHandling with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNoResponseHandling() *NoResponseHandling { + o := &NoResponseHandling{} + o.SetTypeName("Rest$NoResponseHandling") + o.statusCode = property.NewPrimitive[int32]("StatusCode", property.DecodeInt32) + o.statusCode.Bind(&o.Base, 0) + o.contentType = property.NewPrimitive[string]("ContentType", property.DecodeString) + o.contentType.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.statusCode, o.contentType, }) + return o +} + +// NewNoResponseHandling creates a new NoResponseHandling for user code. Marked dirty (bit 63 = new element). +func NewNoResponseHandling() *NoResponseHandling { + o := initNoResponseHandling() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataEntityTypeSource creates a ODataEntityTypeSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataEntityTypeSource() *ODataEntityTypeSource { + o := &ODataEntityTypeSource{} + o.SetTypeName("Rest$ODataEntityTypeSource") + o.sourceDocument = property.NewByNameRef[element.Element]("SourceDocument", "Rest$ConsumedODataService") + o.sourceDocument.Bind(&o.Base, 0) + o.entityTypeName = property.NewPrimitive[string]("EntityTypeName", property.DecodeString) + o.entityTypeName.Bind(&o.Base, 1) + o.key = property.NewPart[element.Element]("Key") + o.key.Bind(&o.Base, 2) + o.isOpen = property.NewPrimitive[bool]("IsOpen", property.DecodeBool) + o.isOpen.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.sourceDocument, o.entityTypeName, o.key, o.isOpen, }) + return o +} + +// NewODataEntityTypeSource creates a new ODataEntityTypeSource for user code. Marked dirty (bit 63 = new element). +func NewODataEntityTypeSource() *ODataEntityTypeSource { + o := initODataEntityTypeSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataKey creates a ODataKey with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataKey() *ODataKey { + o := &ODataKey{} + o.SetTypeName("Rest$ODataKey") + o.parts = property.NewPartList[element.Element]("Parts") + o.parts.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.parts, }) + return o +} + +// NewODataKey creates a new ODataKey for user code. Marked dirty (bit 63 = new element). +func NewODataKey() *ODataKey { + o := initODataKey() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataKeyPart creates a ODataKeyPart with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataKeyPart() *ODataKeyPart { + o := &ODataKeyPart{} + o.SetTypeName("Rest$ODataKeyPart") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.entityKeyPartName = property.NewPrimitive[string]("EntityKeyPartName", property.DecodeString) + o.entityKeyPartName.Bind(&o.Base, 1) + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 2) + o.remoteType = property.NewPrimitive[string]("RemoteType", property.DecodeString) + o.remoteType.Bind(&o.Base, 3) + o.filterable = property.NewPrimitive[bool]("Filterable", property.DecodeBool) + o.filterable.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.entityKeyPartName, o.propType, o.remoteType, o.filterable, }) + return o +} + +// NewODataKeyPart creates a new ODataKeyPart for user code. Marked dirty (bit 63 = new element). +func NewODataKeyPart() *ODataKeyPart { + o := initODataKeyPart() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataMappedPrimitiveCollectionValue creates a ODataMappedPrimitiveCollectionValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataMappedPrimitiveCollectionValue() *ODataMappedPrimitiveCollectionValue { + o := &ODataMappedPrimitiveCollectionValue{} + o.SetTypeName("Rest$ODataMappedPrimitiveCollectionValue") + o.defaultValueDesignTime = property.NewPrimitive[string]("DefaultValueDesignTime", property.DecodeString) + o.defaultValueDesignTime.Bind(&o.Base, 0) + o.remoteName = property.NewPrimitive[string]("RemoteName", property.DecodeString) + o.remoteName.Bind(&o.Base, 1) + o.remoteType = property.NewPrimitive[string]("RemoteType", property.DecodeString) + o.remoteType.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.defaultValueDesignTime, o.remoteName, o.remoteType, }) + return o +} + +// NewODataMappedPrimitiveCollectionValue creates a new ODataMappedPrimitiveCollectionValue for user code. Marked dirty (bit 63 = new element). +func NewODataMappedPrimitiveCollectionValue() *ODataMappedPrimitiveCollectionValue { + o := initODataMappedPrimitiveCollectionValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataMappedValue creates a ODataMappedValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataMappedValue() *ODataMappedValue { + o := &ODataMappedValue{} + o.SetTypeName("Rest$ODataMappedValue") + o.defaultValueDesignTime = property.NewPrimitive[string]("DefaultValueDesignTime", property.DecodeString) + o.defaultValueDesignTime.Bind(&o.Base, 0) + o.remoteName = property.NewPrimitive[string]("RemoteName", property.DecodeString) + o.remoteName.Bind(&o.Base, 1) + o.remoteType = property.NewPrimitive[string]("RemoteType", property.DecodeString) + o.remoteType.Bind(&o.Base, 2) + o.filterable = property.NewPrimitive[bool]("Filterable", property.DecodeBool) + o.filterable.Bind(&o.Base, 3) + o.sortable = property.NewPrimitive[bool]("Sortable", property.DecodeBool) + o.sortable.Bind(&o.Base, 4) + o.representsStream = property.NewPrimitive[bool]("RepresentsStream", property.DecodeBool) + o.representsStream.Bind(&o.Base, 5) + o.updatable = property.NewPrimitive[bool]("Updatable", property.DecodeBool) + o.updatable.Bind(&o.Base, 6) + o.creatable = property.NewPrimitive[bool]("Creatable", property.DecodeBool) + o.creatable.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.defaultValueDesignTime, o.remoteName, o.remoteType, o.filterable, o.sortable, o.representsStream, o.updatable, o.creatable, }) + return o +} + +// NewODataMappedValue creates a new ODataMappedValue for user code. Marked dirty (bit 63 = new element). +func NewODataMappedValue() *ODataMappedValue { + o := initODataMappedValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataPrimitiveCollectionAssociationSource creates a ODataPrimitiveCollectionAssociationSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataPrimitiveCollectionAssociationSource() *ODataPrimitiveCollectionAssociationSource { + o := &ODataPrimitiveCollectionAssociationSource{} + o.SetTypeName("Rest$ODataPrimitiveCollectionAssociationSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, }) + return o +} + +// NewODataPrimitiveCollectionAssociationSource creates a new ODataPrimitiveCollectionAssociationSource for user code. Marked dirty (bit 63 = new element). +func NewODataPrimitiveCollectionAssociationSource() *ODataPrimitiveCollectionAssociationSource { + o := initODataPrimitiveCollectionAssociationSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataPrimitiveCollectionEntitySource creates a ODataPrimitiveCollectionEntitySource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataPrimitiveCollectionEntitySource() *ODataPrimitiveCollectionEntitySource { + o := &ODataPrimitiveCollectionEntitySource{} + o.SetTypeName("Rest$ODataPrimitiveCollectionEntitySource") + o.sourceDocument = property.NewByNameRef[element.Element]("SourceDocument", "Rest$ConsumedODataService") + o.sourceDocument.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.sourceDocument, }) + return o +} + +// NewODataPrimitiveCollectionEntitySource creates a new ODataPrimitiveCollectionEntitySource for user code. Marked dirty (bit 63 = new element). +func NewODataPrimitiveCollectionEntitySource() *ODataPrimitiveCollectionEntitySource { + o := initODataPrimitiveCollectionEntitySource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataRemoteAssociationSource creates a ODataRemoteAssociationSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataRemoteAssociationSource() *ODataRemoteAssociationSource { + o := &ODataRemoteAssociationSource{} + o.SetTypeName("Rest$ODataRemoteAssociationSource") + o.forceFullObjects = property.NewPrimitive[bool]("ForceFullObjects", property.DecodeBool) + o.forceFullObjects.Bind(&o.Base, 0) + o.entityPath = property.NewPrimitive[string]("EntityPath", property.DecodeString) + o.entityPath.Bind(&o.Base, 1) + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 2) + o.sourceVariable = property.NewPart[element.Element]("SourceVariable") + o.sourceVariable.Bind(&o.Base, 3) + o.remoteParentNavigationProperty = property.NewPrimitive[string]("RemoteParentNavigationProperty", property.DecodeString) + o.remoteParentNavigationProperty.Bind(&o.Base, 4) + o.remoteChildNavigationProperty = property.NewPrimitive[string]("RemoteChildNavigationProperty", property.DecodeString) + o.remoteChildNavigationProperty.Bind(&o.Base, 5) + o.navigability = property.NewEnum[string]("Navigability") + o.navigability.Bind(&o.Base, 6) + o.navigability2 = property.NewEnum[string]("Navigability2") + o.navigability2.Bind(&o.Base, 7) + o.updatableFromChild = property.NewPrimitive[bool]("UpdatableFromChild", property.DecodeBool) + o.updatableFromChild.Bind(&o.Base, 8) + o.updatableFromParent = property.NewPrimitive[bool]("UpdatableFromParent", property.DecodeBool) + o.updatableFromParent.Bind(&o.Base, 9) + o.creatableFromChild = property.NewPrimitive[bool]("CreatableFromChild", property.DecodeBool) + o.creatableFromChild.Bind(&o.Base, 10) + o.creatableFromParent = property.NewPrimitive[bool]("CreatableFromParent", property.DecodeBool) + o.creatableFromParent.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.forceFullObjects, o.entityPath, o.entityRef, o.sourceVariable, o.remoteParentNavigationProperty, o.remoteChildNavigationProperty, o.navigability, o.navigability2, o.updatableFromChild, o.updatableFromParent, o.creatableFromChild, o.creatableFromParent, }) + return o +} + +// NewODataRemoteAssociationSource creates a new ODataRemoteAssociationSource for user code. Marked dirty (bit 63 = new element). +func NewODataRemoteAssociationSource() *ODataRemoteAssociationSource { + o := initODataRemoteAssociationSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataRemoteEntitySource creates a ODataRemoteEntitySource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataRemoteEntitySource() *ODataRemoteEntitySource { + o := &ODataRemoteEntitySource{} + o.SetTypeName("Rest$ODataRemoteEntitySource") + o.sourceDocument = property.NewByNameRef[element.Element]("SourceDocument", "Rest$ConsumedODataService") + o.sourceDocument.Bind(&o.Base, 0) + o.remoteName = property.NewPrimitive[string]("RemoteName", property.DecodeString) + o.remoteName.Bind(&o.Base, 1) + o.entityTypeName = property.NewPrimitive[string]("EntityTypeName", property.DecodeString) + o.entityTypeName.Bind(&o.Base, 2) + o.entitySet = property.NewPrimitive[string]("EntitySet", property.DecodeString) + o.entitySet.Bind(&o.Base, 3) + o.entitySetName = property.NewPrimitive[string]("EntitySetName", property.DecodeString) + o.entitySetName.Bind(&o.Base, 4) + o.key = property.NewPart[element.Element]("Key") + o.key.Bind(&o.Base, 5) + o.countable = property.NewPrimitive[bool]("Countable", property.DecodeBool) + o.countable.Bind(&o.Base, 6) + o.creatable = property.NewPrimitive[bool]("Creatable", property.DecodeBool) + o.creatable.Bind(&o.Base, 7) + o.deletable = property.NewPrimitive[bool]("Deletable", property.DecodeBool) + o.deletable.Bind(&o.Base, 8) + o.topSupported = property.NewPrimitive[bool]("TopSupported", property.DecodeBool) + o.topSupported.Bind(&o.Base, 9) + o.skipSupported = property.NewPrimitive[bool]("SkipSupported", property.DecodeBool) + o.skipSupported.Bind(&o.Base, 10) + o.createChangeLocally = property.NewPrimitive[bool]("CreateChangeLocally", property.DecodeBool) + o.createChangeLocally.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.sourceDocument, o.remoteName, o.entityTypeName, o.entitySet, o.entitySetName, o.key, o.countable, o.creatable, o.deletable, o.topSupported, o.skipSupported, o.createChangeLocally, }) + return o +} + +// NewODataRemoteEntitySource creates a new ODataRemoteEntitySource for user code. Marked dirty (bit 63 = new element). +func NewODataRemoteEntitySource() *ODataRemoteEntitySource { + o := initODataRemoteEntitySource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataRemoteEnumerationSource creates a ODataRemoteEnumerationSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataRemoteEnumerationSource() *ODataRemoteEnumerationSource { + o := &ODataRemoteEnumerationSource{} + o.SetTypeName("Rest$ODataRemoteEnumerationSource") + o.consumedODataService = property.NewByNameRef[element.Element]("ConsumedODataService", "Rest$ConsumedODataService") + o.consumedODataService.Bind(&o.Base, 0) + o.remoteName = property.NewPrimitive[string]("RemoteName", property.DecodeString) + o.remoteName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.consumedODataService, o.remoteName, }) + return o +} + +// NewODataRemoteEnumerationSource creates a new ODataRemoteEnumerationSource for user code. Marked dirty (bit 63 = new element). +func NewODataRemoteEnumerationSource() *ODataRemoteEnumerationSource { + o := initODataRemoteEnumerationSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initODataRemoteEnumerationValue creates a ODataRemoteEnumerationValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initODataRemoteEnumerationValue() *ODataRemoteEnumerationValue { + o := &ODataRemoteEnumerationValue{} + o.SetTypeName("Rest$ODataRemoteEnumerationValue") + o.remoteName = property.NewPrimitive[string]("RemoteName", property.DecodeString) + o.remoteName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.remoteName, }) + return o +} + +// NewODataRemoteEnumerationValue creates a new ODataRemoteEnumerationValue for user code. Marked dirty (bit 63 = new element). +func NewODataRemoteEnumerationValue() *ODataRemoteEnumerationValue { + o := initODataRemoteEnumerationValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOpenApiFile creates a OpenApiFile with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOpenApiFile() *OpenApiFile { + o := &OpenApiFile{} + o.SetTypeName("Rest$OpenApiFile") + o.content = property.NewPrimitive[string]("Content", property.DecodeString) + o.content.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.content, }) + return o +} + +// NewOpenApiFile creates a new OpenApiFile for user code. Marked dirty (bit 63 = new element). +func NewOpenApiFile() *OpenApiFile { + o := initOpenApiFile() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOperationParameter creates a OperationParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOperationParameter() *OperationParameter { + o := &OperationParameter{} + o.SetTypeName("Rest$OperationParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.dataType = property.NewPart[element.Element]("DataType") + o.dataType.Bind(&o.Base, 1) + o.testValue = property.NewPart[element.Element]("TestValue") + o.testValue.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.dataType, o.testValue, }) + return o +} + +// NewOperationParameter creates a new OperationParameter for user code. Marked dirty (bit 63 = new element). +func NewOperationParameter() *OperationParameter { + o := initOperationParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOptionalQueryParameterUsage creates a OptionalQueryParameterUsage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOptionalQueryParameterUsage() *OptionalQueryParameterUsage { + o := &OptionalQueryParameterUsage{} + o.SetTypeName("Rest$OptionalQueryParameterUsage") + o.included = property.NewPrimitive[bool]("Included", property.DecodeBool) + o.included.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.included, }) + return o +} + +// NewOptionalQueryParameterUsage creates a new OptionalQueryParameterUsage for user code. Marked dirty (bit 63 = new element). +func NewOptionalQueryParameterUsage() *OptionalQueryParameterUsage { + o := initOptionalQueryParameterUsage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedODataContract creates a PublishedODataContract with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedODataContract() *PublishedODataContract { + o := &PublishedODataContract{} + o.SetTypeName("Rest$PublishedODataContract") + o.serviceFeed = property.NewPart[element.Element]("ServiceFeed") + o.serviceFeed.Bind(&o.Base, 0) + o.metadata = property.NewPrimitive[string]("Metadata", property.DecodeString) + o.metadata.Bind(&o.Base, 1) + o.openApi = property.NewPrimitive[string]("OpenApi", property.DecodeString) + o.openApi.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.serviceFeed, o.metadata, o.openApi, }) + return o +} + +// NewPublishedODataContract creates a new PublishedODataContract for user code. Marked dirty (bit 63 = new element). +func NewPublishedODataContract() *PublishedODataContract { + o := initPublishedODataContract() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedODataEnumeration creates a PublishedODataEnumeration with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedODataEnumeration() *PublishedODataEnumeration { + o := &PublishedODataEnumeration{} + o.SetTypeName("Rest$PublishedODataEnumeration") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.enumeration = property.NewByNameRef[element.Element]("Enumeration", "Enumerations$Enumeration") + o.enumeration.Bind(&o.Base, 1) + o.values = property.NewPartList[element.Element]("Values") + o.values.Bind(&o.Base, 2) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 3) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.exposedName, o.enumeration, o.values, o.summary, o.description, }) + return o +} + +// NewPublishedODataEnumeration creates a new PublishedODataEnumeration for user code. Marked dirty (bit 63 = new element). +func NewPublishedODataEnumeration() *PublishedODataEnumeration { + o := initPublishedODataEnumeration() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedODataEnumerationValue creates a PublishedODataEnumerationValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedODataEnumerationValue() *PublishedODataEnumerationValue { + o := &PublishedODataEnumerationValue{} + o.SetTypeName("Rest$PublishedODataEnumerationValue") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.enumerationValue = property.NewByNameRef[element.Element]("EnumerationValue", "Enumerations$EnumerationValue") + o.enumerationValue.Bind(&o.Base, 1) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 2) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.exposedName, o.enumerationValue, o.summary, o.description, }) + return o +} + +// NewPublishedODataEnumerationValue creates a new PublishedODataEnumerationValue for user code. Marked dirty (bit 63 = new element). +func NewPublishedODataEnumerationValue() *PublishedODataEnumerationValue { + o := initPublishedODataEnumerationValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedODataMicroflow creates a PublishedODataMicroflow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedODataMicroflow() *PublishedODataMicroflow { + o := &PublishedODataMicroflow{} + o.SetTypeName("Rest$PublishedODataMicroflow") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 1) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 2) + o.returnType = property.NewPart[element.Element]("ReturnType") + o.returnType.Bind(&o.Base, 3) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 4) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.exposedName, o.microflow, o.parameters, o.returnType, o.summary, o.description, }) + return o +} + +// NewPublishedODataMicroflow creates a new PublishedODataMicroflow for user code. Marked dirty (bit 63 = new element). +func NewPublishedODataMicroflow() *PublishedODataMicroflow { + o := initPublishedODataMicroflow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedODataMicroflowParameter creates a PublishedODataMicroflowParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedODataMicroflowParameter() *PublishedODataMicroflowParameter { + o := &PublishedODataMicroflowParameter{} + o.SetTypeName("Rest$PublishedODataMicroflowParameter") + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 0) + o.microflowParameter = property.NewByNameRef[element.Element]("MicroflowParameter", "Microflows$MicroflowParameter") + o.microflowParameter.Bind(&o.Base, 1) + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 2) + o.dataType = property.NewPart[element.Element]("DataType") + o.dataType.Bind(&o.Base, 3) + o.canBeEmpty = property.NewPrimitive[bool]("CanBeEmpty", property.DecodeBool) + o.canBeEmpty.Bind(&o.Base, 4) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 5) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.exposedName, o.microflowParameter, o.propType, o.dataType, o.canBeEmpty, o.summary, o.description, }) + return o +} + +// NewPublishedODataMicroflowParameter creates a new PublishedODataMicroflowParameter for user code. Marked dirty (bit 63 = new element). +func NewPublishedODataMicroflowParameter() *PublishedODataMicroflowParameter { + o := initPublishedODataMicroflowParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedODataService creates a PublishedODataService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedODataService() *PublishedODataService { + o := &PublishedODataService{} + o.SetTypeName("Rest$PublishedODataService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.namespace = property.NewPrimitive[string]("Namespace", property.DecodeString) + o.namespace.Bind(&o.Base, 4) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 5) + o.allowedModuleRoles = property.NewByNameRefList[element.Element]("AllowedModuleRoles", "Security$ModuleRole") + o.allowedModuleRoles.Bind(&o.Base, 6) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 7) + o.resources = property.NewPartList[element.Element]("Resources") + o.resources.Bind(&o.Base, 8) + o.microflows = property.NewPartList[element.Element]("Microflows") + o.microflows.Bind(&o.Base, 9) + o.enumerations = property.NewPartList[element.Element]("Enumerations") + o.enumerations.Bind(&o.Base, 10) + o.publishAssociations = property.NewPrimitive[bool]("PublishAssociations", property.DecodeBool) + o.publishAssociations.Bind(&o.Base, 11) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 12) + o.authenticationMicroflow = property.NewByNameRef[element.Element]("AuthenticationMicroflow", "Microflows$Microflow") + o.authenticationMicroflow.Bind(&o.Base, 13) + o.authenticationTypes = property.NewEnumList[string]("AuthenticationTypes") + o.authenticationTypes.Bind(&o.Base, 14) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 15) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 16) + o.replaceIllegalChars = property.NewPrimitive[bool]("ReplaceIllegalChars", property.DecodeBool) + o.replaceIllegalChars.Bind(&o.Base, 17) + o.useGeneralization = property.NewPrimitive[bool]("UseGeneralization", property.DecodeBool) + o.useGeneralization.Bind(&o.Base, 18) + o.oDataVersion = property.NewEnum[string]("ODataVersion") + o.oDataVersion.Bind(&o.Base, 19) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.namespace, o.path, o.allowedModuleRoles, o.serviceName, o.resources, o.microflows, o.enumerations, o.publishAssociations, o.version, o.authenticationMicroflow, o.authenticationTypes, o.summary, o.description, o.replaceIllegalChars, o.useGeneralization, o.oDataVersion, }) + return o +} + +// NewPublishedODataService creates a new PublishedODataService for user code. Marked dirty (bit 63 = new element). +func NewPublishedODataService() *PublishedODataService { + o := initPublishedODataService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedRestResource creates a PublishedRestResource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedRestResource() *PublishedRestResource { + o := &PublishedRestResource{} + o.SetTypeName("Rest$PublishedRestResource") + o.dataEntity = property.NewPart[element.Element]("DataEntity") + o.dataEntity.Bind(&o.Base, 0) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 1) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 2) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 3) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 4) + o.usePaging = property.NewPrimitive[bool]("UsePaging", property.DecodeBool) + o.usePaging.Bind(&o.Base, 5) + o.pageSize = property.NewPrimitive[int32]("PageSize", property.DecodeInt32) + o.pageSize.Bind(&o.Base, 6) + o.updatable = property.NewPrimitive[bool]("Updatable", property.DecodeBool) + o.updatable.Bind(&o.Base, 7) + o.updateMicroflow = property.NewByNameRef[element.Element]("UpdateMicroflow", "Microflows$Microflow") + o.updateMicroflow.Bind(&o.Base, 8) + o.insertable = property.NewPrimitive[bool]("Insertable", property.DecodeBool) + o.insertable.Bind(&o.Base, 9) + o.deletable = property.NewPrimitive[bool]("Deletable", property.DecodeBool) + o.deletable.Bind(&o.Base, 10) + o.updateMode = property.NewPart[element.Element]("UpdateMode") + o.updateMode.Bind(&o.Base, 11) + o.insertMode = property.NewPart[element.Element]("InsertMode") + o.insertMode.Bind(&o.Base, 12) + o.deleteMode = property.NewPart[element.Element]("DeleteMode") + o.deleteMode.Bind(&o.Base, 13) + o.readMode = property.NewPart[element.Element]("ReadMode") + o.readMode.Bind(&o.Base, 14) + o.queryOptions = property.NewPart[element.Element]("QueryOptions") + o.queryOptions.Bind(&o.Base, 15) + o.queryMicroflow = property.NewByNameRef[element.Element]("QueryMicroflow", "Microflows$Microflow") + o.queryMicroflow.Bind(&o.Base, 16) + o.countMicroflow = property.NewByNameRef[element.Element]("CountMicroflow", "Microflows$Microflow") + o.countMicroflow.Bind(&o.Base, 17) + o.SetProperties([]element.Property{o.dataEntity, o.path, o.exposedName, o.summary, o.description, o.usePaging, o.pageSize, o.updatable, o.updateMicroflow, o.insertable, o.deletable, o.updateMode, o.insertMode, o.deleteMode, o.readMode, o.queryOptions, o.queryMicroflow, o.countMicroflow, }) + return o +} + +// NewPublishedRestResource creates a new PublishedRestResource for user code. Marked dirty (bit 63 = new element). +func NewPublishedRestResource() *PublishedRestResource { + o := initPublishedRestResource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedRestService creates a PublishedRestService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedRestService() *PublishedRestService { + o := &PublishedRestService{} + o.SetTypeName("Rest$PublishedRestService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 4) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 5) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 6) + o.authenticationType = property.NewEnum[string]("AuthenticationType") + o.authenticationType.Bind(&o.Base, 7) + o.authenticationTypes = property.NewEnumList[string]("AuthenticationTypes") + o.authenticationTypes.Bind(&o.Base, 8) + o.authenticationMicroflow = property.NewByNameRef[element.Element]("AuthenticationMicroflow", "Microflows$Microflow") + o.authenticationMicroflow.Bind(&o.Base, 9) + o.corsConfiguration = property.NewPart[element.Element]("CorsConfiguration") + o.corsConfiguration.Bind(&o.Base, 10) + o.allowedRoles = property.NewByNameRefList[element.Element]("AllowedRoles", "Security$ModuleRole") + o.allowedRoles.Bind(&o.Base, 11) + o.resources = property.NewPartList[element.Element]("Resources") + o.resources.Bind(&o.Base, 12) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 13) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.path, o.serviceName, o.version, o.authenticationType, o.authenticationTypes, o.authenticationMicroflow, o.corsConfiguration, o.allowedRoles, o.resources, o.parameters, }) + return o +} + +// NewPublishedRestService creates a new PublishedRestService for user code. Marked dirty (bit 63 = new element). +func NewPublishedRestService() *PublishedRestService { + o := initPublishedRestService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedRestServiceOperation creates a PublishedRestServiceOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedRestServiceOperation() *PublishedRestServiceOperation { + o := &PublishedRestServiceOperation{} + o.SetTypeName("Rest$PublishedRestServiceOperation") + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.deprecated = property.NewPrimitive[bool]("Deprecated", property.DecodeBool) + o.deprecated.Bind(&o.Base, 3) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 4) + o.httpMethod = property.NewEnum[string]("HttpMethod") + o.httpMethod.Bind(&o.Base, 5) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 6) + o.exportMapping = property.NewByNameRef[element.Element]("ExportMapping", "ExportMappings$ExportMapping") + o.exportMapping.Bind(&o.Base, 7) + o.importMapping = property.NewByNameRef[element.Element]("ImportMapping", "ImportMappings$ImportMapping") + o.importMapping.Bind(&o.Base, 8) + o.objectHandlingBackup = property.NewEnum[string]("ObjectHandlingBackup") + o.objectHandlingBackup.Bind(&o.Base, 9) + o.commit = property.NewEnum[string]("Commit") + o.commit.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.summary, o.documentation, o.path, o.deprecated, o.parameters, o.httpMethod, o.microflow, o.exportMapping, o.importMapping, o.objectHandlingBackup, o.commit, }) + return o +} + +// NewPublishedRestServiceOperation creates a new PublishedRestServiceOperation for user code. Marked dirty (bit 63 = new element). +func NewPublishedRestServiceOperation() *PublishedRestServiceOperation { + o := initPublishedRestServiceOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedRestServiceResource creates a PublishedRestServiceResource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedRestServiceResource() *PublishedRestServiceResource { + o := &PublishedRestServiceResource{} + o.SetTypeName("Rest$PublishedRestServiceResource") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.operations = property.NewPartList[element.Element]("Operations") + o.operations.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.documentation, o.operations, }) + return o +} + +// NewPublishedRestServiceResource creates a new PublishedRestServiceResource for user code. Marked dirty (bit 63 = new element). +func NewPublishedRestServiceResource() *PublishedRestServiceResource { + o := initPublishedRestServiceResource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initQueryOptions creates a QueryOptions with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initQueryOptions() *QueryOptions { + o := &QueryOptions{} + o.SetTypeName("Rest$QueryOptions") + o.countable = property.NewPrimitive[bool]("Countable", property.DecodeBool) + o.countable.Bind(&o.Base, 0) + o.topSupported = property.NewPrimitive[bool]("TopSupported", property.DecodeBool) + o.topSupported.Bind(&o.Base, 1) + o.skipSupported = property.NewPrimitive[bool]("SkipSupported", property.DecodeBool) + o.skipSupported.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.countable, o.topSupported, o.skipSupported, }) + return o +} + +// NewQueryOptions creates a new QueryOptions for user code. Marked dirty (bit 63 = new element). +func NewQueryOptions() *QueryOptions { + o := initQueryOptions() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initQueryParameter creates a QueryParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initQueryParameter() *QueryParameter { + o := &QueryParameter{} + o.SetTypeName("Rest$QueryParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.testValue = property.NewPrimitive[string]("TestValue", property.DecodeString) + o.testValue.Bind(&o.Base, 1) + o.parameterUsage = property.NewPart[element.Element]("ParameterUsage") + o.parameterUsage.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.testValue, o.parameterUsage, }) + return o +} + +// NewQueryParameter creates a new QueryParameter for user code. Marked dirty (bit 63 = new element). +func NewQueryParameter() *QueryParameter { + o := initQueryParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initReadSource creates a ReadSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initReadSource() *ReadSource { + o := &ReadSource{} + o.SetTypeName("Rest$ReadSource") + o.SetProperties([]element.Property{}) + return o +} + +// NewReadSource creates a new ReadSource for user code. Marked dirty (bit 63 = new element). +func NewReadSource() *ReadSource { + o := initReadSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRequiredQueryParameterUsage creates a RequiredQueryParameterUsage with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRequiredQueryParameterUsage() *RequiredQueryParameterUsage { + o := &RequiredQueryParameterUsage{} + o.SetTypeName("Rest$RequiredQueryParameterUsage") + o.SetProperties([]element.Property{}) + return o +} + +// NewRequiredQueryParameterUsage creates a new RequiredQueryParameterUsage for user code. Marked dirty (bit 63 = new element). +func NewRequiredQueryParameterUsage() *RequiredQueryParameterUsage { + o := initRequiredQueryParameterUsage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestOperation creates a RestOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestOperation() *RestOperation { + o := &RestOperation{} + o.SetTypeName("Rest$RestOperation") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.path = property.NewPart[element.Element]("Path") + o.path.Bind(&o.Base, 1) + o.method = property.NewPart[element.Element]("Method") + o.method.Bind(&o.Base, 2) + o.timeout = property.NewPrimitive[int32]("Timeout", property.DecodeInt32) + o.timeout.Bind(&o.Base, 3) + o.headers = property.NewPartList[element.Element]("Headers") + o.headers.Bind(&o.Base, 4) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 5) + o.queryParameters = property.NewPartList[element.Element]("QueryParameters") + o.queryParameters.Bind(&o.Base, 6) + o.responseHandling = property.NewPart[element.Element]("ResponseHandling") + o.responseHandling.Bind(&o.Base, 7) + o.tags = property.NewPrimitive[string]("Tags", property.DecodeString) + o.tags.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.name, o.path, o.method, o.timeout, o.headers, o.parameters, o.queryParameters, o.responseHandling, o.tags, }) + return o +} + +// NewRestOperation creates a new RestOperation for user code. Marked dirty (bit 63 = new element). +func NewRestOperation() *RestOperation { + o := initRestOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestOperationMethodWithBody creates a RestOperationMethodWithBody with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestOperationMethodWithBody() *RestOperationMethodWithBody { + o := &RestOperationMethodWithBody{} + o.SetTypeName("Rest$RestOperationMethodWithBody") + o.httpMethod = property.NewEnum[string]("HttpMethod") + o.httpMethod.Bind(&o.Base, 0) + o.body = property.NewPart[element.Element]("Body") + o.body.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.httpMethod, o.body, }) + return o +} + +// NewRestOperationMethodWithBody creates a new RestOperationMethodWithBody for user code. Marked dirty (bit 63 = new element). +func NewRestOperationMethodWithBody() *RestOperationMethodWithBody { + o := initRestOperationMethodWithBody() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestOperationMethodWithoutBody creates a RestOperationMethodWithoutBody with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestOperationMethodWithoutBody() *RestOperationMethodWithoutBody { + o := &RestOperationMethodWithoutBody{} + o.SetTypeName("Rest$RestOperationMethodWithoutBody") + o.httpMethod = property.NewEnum[string]("HttpMethod") + o.httpMethod.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.httpMethod, }) + return o +} + +// NewRestOperationMethodWithoutBody creates a new RestOperationMethodWithoutBody for user code. Marked dirty (bit 63 = new element). +func NewRestOperationMethodWithoutBody() *RestOperationMethodWithoutBody { + o := initRestOperationMethodWithoutBody() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestOperationParameter creates a RestOperationParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestOperationParameter() *RestOperationParameter { + o := &RestOperationParameter{} + o.SetTypeName("Rest$RestOperationParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.microflowParameter = property.NewByNameRef[element.Element]("MicroflowParameter", "Microflows$MicroflowParameter") + o.microflowParameter.Bind(&o.Base, 1) + o.propType = property.NewPart[element.Element]("Type") + o.propType.Bind(&o.Base, 2) + o.parameterType = property.NewEnum[string]("ParameterType") + o.parameterType.Bind(&o.Base, 3) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 4) + o.dataType = property.NewPrimitive[string]("DataType", property.DecodeString) + o.dataType.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.microflowParameter, o.propType, o.parameterType, o.description, o.dataType, }) + return o +} + +// NewRestOperationParameter creates a new RestOperationParameter for user code. Marked dirty (bit 63 = new element). +func NewRestOperationParameter() *RestOperationParameter { + o := initRestOperationParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestParameter creates a RestParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestParameter() *RestParameter { + o := &RestParameter{} + o.SetTypeName("Rest$RestParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.dataType = property.NewPart[element.Element]("DataType") + o.dataType.Bind(&o.Base, 1) + o.testValue = property.NewPart[element.Element]("TestValue") + o.testValue.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.name, o.dataType, o.testValue, }) + return o +} + +// NewRestParameter creates a new RestParameter for user code. Marked dirty (bit 63 = new element). +func NewRestParameter() *RestParameter { + o := initRestParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initServiceFeed creates a ServiceFeed with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initServiceFeed() *ServiceFeed { + o := &ServiceFeed{} + o.SetTypeName("Rest$ServiceFeed") + o.xml = property.NewPrimitive[string]("Xml", property.DecodeString) + o.xml.Bind(&o.Base, 0) + o.json = property.NewPrimitive[string]("Json", property.DecodeString) + o.json.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.xml, o.json, }) + return o +} + +// NewServiceFeed creates a new ServiceFeed for user code. Marked dirty (bit 63 = new element). +func NewServiceFeed() *ServiceFeed { + o := initServiceFeed() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringBody creates a StringBody with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringBody() *StringBody { + o := &StringBody{} + o.SetTypeName("Rest$StringBody") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.valueTemplate = property.NewPart[element.Element]("ValueTemplate") + o.valueTemplate.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.value, o.valueTemplate, }) + return o +} + +// NewStringBody creates a new StringBody for user code. Marked dirty (bit 63 = new element). +func NewStringBody() *StringBody { + o := initStringBody() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringValue creates a StringValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringValue() *StringValue { + o := &StringValue{} + o.SetTypeName("Rest$StringValue") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value, }) + return o +} + +// NewStringValue creates a new StringValue for user code. Marked dirty (bit 63 = new element). +func NewStringValue() *StringValue { + o := initStringValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initValueTemplate creates a ValueTemplate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initValueTemplate() *ValueTemplate { + o := &ValueTemplate{} + o.SetTypeName("Rest$ValueTemplate") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value, }) + return o +} + +// NewValueTemplate creates a new ValueTemplate for user code. Marked dirty (bit 63 = new element). +func NewValueTemplate() *ValueTemplate { + o := initValueTemplate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestCallOperation creates a RestCallOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestCallOperation() *RestCallOperation { + o := &RestCallOperation{} + o.SetTypeName("Rest$RestCallOperation") + o.httpMethod = property.NewPrimitive[string]("HttpMethod", property.DecodeString) + o.httpMethod.Bind(&o.Base, 0) + o.url = property.NewPrimitive[string]("Url", property.DecodeString) + o.url.Bind(&o.Base, 1) + o.timeoutExpression = property.NewPrimitive[string]("TimeoutExpression", property.DecodeString) + o.timeoutExpression.Bind(&o.Base, 2) + o.proxyType = property.NewPrimitive[string]("ProxyType", property.DecodeString) + o.proxyType.Bind(&o.Base, 3) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 4) + o.queryParameters = property.NewPartList[element.Element]("QueryParameters") + o.queryParameters.Bind(&o.Base, 5) + o.headers = property.NewPartList[element.Element]("Headers") + o.headers.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.httpMethod, o.url, o.timeoutExpression, o.proxyType, o.parameters, o.queryParameters, o.headers, }) + return o +} + +// NewRestCallOperation creates a new RestCallOperation for user code. Marked dirty (bit 63 = new element). +func NewRestCallOperation() *RestCallOperation { + o := initRestCallOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestCallParameter creates a RestCallParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestCallParameter() *RestCallParameter { + o := &RestCallParameter{} + o.SetTypeName("Rest$RestCallParameter") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 1) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 2) + o.testValue = property.NewPrimitive[string]("TestValue", property.DecodeString) + o.testValue.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.name, o.propType, o.value, o.testValue, }) + return o +} + +// NewRestCallParameter creates a new RestCallParameter for user code. Marked dirty (bit 63 = new element). +func NewRestCallParameter() *RestCallParameter { + o := initRestCallParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRestCallHeader creates a RestCallHeader with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRestCallHeader() *RestCallHeader { + o := &RestCallHeader{} + o.SetTypeName("Rest$RestCallHeader") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.value, }) + return o +} + +// NewRestCallHeader creates a new RestCallHeader for user code. Marked dirty (bit 63 = new element). +func NewRestCallHeader() *RestCallHeader { + o := initRestCallHeader() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedRestOperation creates a PublishedRestOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedRestOperation() *PublishedRestOperation { + o := &PublishedRestOperation{} + o.SetTypeName("Rest$PublishedRestOperation") + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 0) + o.httpMethod = property.NewPrimitive[string]("HttpMethod", property.DecodeString) + o.httpMethod.Bind(&o.Base, 1) + o.deprecated = property.NewPrimitive[bool]("Deprecated", property.DecodeBool) + o.deprecated.Bind(&o.Base, 2) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 3) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 4) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 5) + o.importMapping = property.NewByNameRef[element.Element]("ImportMapping", "ImportMappings$ImportMapping") + o.importMapping.Bind(&o.Base, 6) + o.exportMapping = property.NewByNameRef[element.Element]("ExportMapping", "ExportMappings$ExportMapping") + o.exportMapping.Bind(&o.Base, 7) + o.objectHandlingBackup = property.NewPrimitive[string]("ObjectHandlingBackup", property.DecodeString) + o.objectHandlingBackup.Bind(&o.Base, 8) + o.commit = property.NewPrimitive[string]("Commit", property.DecodeString) + o.commit.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.path, o.httpMethod, o.deprecated, o.summary, o.description, o.microflow, o.importMapping, o.exportMapping, o.objectHandlingBackup, o.commit, }) + return o +} + +// NewPublishedRestOperation creates a new PublishedRestOperation for user code. Marked dirty (bit 63 = new element). +func NewPublishedRestOperation() *PublishedRestOperation { + o := initPublishedRestOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + + +func init() { + codec.DefaultRegistry.Register("Rest$BasicAuthenticationScheme", func() element.Element { + o := initBasicAuthenticationScheme() + o.SetTypeName("Rest$BasicAuthenticationScheme") + return o + }) + codec.DefaultRegistry.Register("Rest$BasicAuthentication", func() element.Element { + return initBasicAuthenticationScheme() + }) + codec.DefaultRegistry.Register("Rest$CallMicroflowToChange", func() element.Element { + return initCallMicroflowToChange() + }) + codec.DefaultRegistry.Register("Rest$CallMicroflowToRead", func() element.Element { + return initCallMicroflowToRead() + }) + codec.DefaultRegistry.Register("Rest$ChangeNotSupported", func() element.Element { + return initChangeNotSupported() + }) + codec.DefaultRegistry.Register("Rest$ChangeSource", func() element.Element { + return initChangeSource() + }) + codec.DefaultRegistry.Register("Rest$ConstantValue", func() element.Element { + return initConstantValue() + }) + codec.DefaultRegistry.Register("Rest$ConsumedODataService", func() element.Element { + return initConsumedODataService() + }) + codec.DefaultRegistry.Register("Rest$ConsumedRestService", func() element.Element { + return initConsumedRestService() + }) + codec.DefaultRegistry.Register("Rest$CorsConfiguration", func() element.Element { + return initCorsConfiguration() + }) + codec.DefaultRegistry.Register("Rest$HeaderWithValueTemplate", func() element.Element { + return initHeaderWithValueTemplate() + }) + codec.DefaultRegistry.Register("Rest$ImplicitMappingBody", func() element.Element { + return initImplicitMappingBody() + }) + codec.DefaultRegistry.Register("Rest$ImplicitMappingResponseHandling", func() element.Element { + return initImplicitMappingResponseHandling() + }) + codec.DefaultRegistry.Register("Rest$JsonBody", func() element.Element { + return initJsonBody() + }) + codec.DefaultRegistry.Register("Rest$MetadataReference", func() element.Element { + return initMetadataReference() + }) + codec.DefaultRegistry.Register("Rest$NoResponseHandling", func() element.Element { + return initNoResponseHandling() + }) + codec.DefaultRegistry.Register("Rest$ODataEntityTypeSource", func() element.Element { + return initODataEntityTypeSource() + }) + codec.DefaultRegistry.Register("Rest$ODataKey", func() element.Element { + return initODataKey() + }) + codec.DefaultRegistry.Register("Rest$ODataKeyPart", func() element.Element { + return initODataKeyPart() + }) + codec.DefaultRegistry.Register("Rest$ODataMappedPrimitiveCollectionValue", func() element.Element { + return initODataMappedPrimitiveCollectionValue() + }) + codec.DefaultRegistry.Register("Rest$ODataMappedValue", func() element.Element { + return initODataMappedValue() + }) + codec.DefaultRegistry.Register("Rest$ODataPrimitiveCollectionAssociationSource", func() element.Element { + return initODataPrimitiveCollectionAssociationSource() + }) + codec.DefaultRegistry.Register("Rest$ODataPrimitiveCollectionEntitySource", func() element.Element { + return initODataPrimitiveCollectionEntitySource() + }) + codec.DefaultRegistry.Register("Rest$ODataRemoteAssociationSource", func() element.Element { + return initODataRemoteAssociationSource() + }) + codec.DefaultRegistry.Register("Rest$ODataRemoteEntitySource", func() element.Element { + return initODataRemoteEntitySource() + }) + codec.DefaultRegistry.Register("Rest$ODataRemoteEnumerationSource", func() element.Element { + return initODataRemoteEnumerationSource() + }) + codec.DefaultRegistry.Register("Rest$ODataRemoteEnumerationValue", func() element.Element { + return initODataRemoteEnumerationValue() + }) + codec.DefaultRegistry.Register("Rest$OpenApiFile", func() element.Element { + return initOpenApiFile() + }) + codec.DefaultRegistry.Register("Rest$OperationParameter", func() element.Element { + return initOperationParameter() + }) + codec.DefaultRegistry.Register("Rest$OptionalQueryParameterUsage", func() element.Element { + return initOptionalQueryParameterUsage() + }) + codec.DefaultRegistry.Register("Rest$PublishedODataContract", func() element.Element { + return initPublishedODataContract() + }) + codec.DefaultRegistry.Register("Rest$PublishedODataEnumeration", func() element.Element { + return initPublishedODataEnumeration() + }) + codec.DefaultRegistry.Register("Rest$PublishedODataEnumerationValue", func() element.Element { + return initPublishedODataEnumerationValue() + }) + codec.DefaultRegistry.Register("Rest$PublishedODataMicroflow", func() element.Element { + return initPublishedODataMicroflow() + }) + codec.DefaultRegistry.Register("Rest$PublishedODataMicroflowParameter", func() element.Element { + return initPublishedODataMicroflowParameter() + }) + codec.DefaultRegistry.Register("Rest$PublishedODataService", func() element.Element { + return initPublishedODataService() + }) + codec.DefaultRegistry.Register("Rest$PublishedRestResource", func() element.Element { + return initPublishedRestResource() + }) + codec.DefaultRegistry.Register("Rest$PublishedRestService", func() element.Element { + return initPublishedRestService() + }) + codec.DefaultRegistry.Register("Rest$PublishedRestServiceOperation", func() element.Element { + return initPublishedRestServiceOperation() + }) + codec.DefaultRegistry.Register("Rest$PublishedRestServiceResource", func() element.Element { + return initPublishedRestServiceResource() + }) + codec.DefaultRegistry.Register("Rest$QueryOptions", func() element.Element { + return initQueryOptions() + }) + codec.DefaultRegistry.Register("Rest$QueryParameter", func() element.Element { + return initQueryParameter() + }) + codec.DefaultRegistry.Register("Rest$ReadSource", func() element.Element { + return initReadSource() + }) + codec.DefaultRegistry.Register("Rest$RequiredQueryParameterUsage", func() element.Element { + return initRequiredQueryParameterUsage() + }) + codec.DefaultRegistry.Register("Rest$RestOperation", func() element.Element { + return initRestOperation() + }) + codec.DefaultRegistry.Register("Rest$RestOperationMethodWithBody", func() element.Element { + return initRestOperationMethodWithBody() + }) + codec.DefaultRegistry.Register("Rest$RestOperationMethodWithoutBody", func() element.Element { + return initRestOperationMethodWithoutBody() + }) + codec.DefaultRegistry.Register("Rest$RestOperationParameter", func() element.Element { + return initRestOperationParameter() + }) + codec.DefaultRegistry.Register("Rest$RestParameter", func() element.Element { + return initRestParameter() + }) + codec.DefaultRegistry.Register("Rest$ServiceFeed", func() element.Element { + return initServiceFeed() + }) + codec.DefaultRegistry.Register("Rest$StringBody", func() element.Element { + return initStringBody() + }) + codec.DefaultRegistry.Register("Rest$StringValue", func() element.Element { + return initStringValue() + }) + codec.DefaultRegistry.Register("Rest$ValueTemplate", func() element.Element { + return initValueTemplate() + }) + codec.DefaultRegistry.Register("Rest$RestCallOperation", func() element.Element { + return initRestCallOperation() + }) + codec.DefaultRegistry.Register("Rest$RestCallParameter", func() element.Element { + return initRestCallParameter() + }) + codec.DefaultRegistry.Register("Rest$RestCallHeader", func() element.Element { + return initRestCallHeader() + }) + codec.DefaultRegistry.Register("Rest$PublishedRestOperation", func() element.Element { + return initPublishedRestOperation() + }) +} diff --git a/modelsdk/gen/rest/version.go b/modelsdk/gen/rest/version.go new file mode 100644 index 00000000..11567349 --- /dev/null +++ b/modelsdk/gen/rest/version.go @@ -0,0 +1,281 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package rest + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Rest$BasicAuthenticationScheme": { + Properties: map[string]version.PropertyVersionInfo{ + "password": {Required: true}, + "username": {Required: true}, + }, + }, + "Rest$BasicAuthentication": { + Properties: map[string]version.PropertyVersionInfo{ + "password": {Required: true}, + "username": {Required: true}, + }, + }, + "Rest$CallMicroflowToChange": { + Properties: map[string]version.PropertyVersionInfo{ + "microflow": {Required: true}, + }, + }, + "Rest$CallMicroflowToRead": { + Properties: map[string]version.PropertyVersionInfo{ + "microflow": {}, + }, + }, + "Rest$ConstantValue": { + Properties: map[string]version.PropertyVersionInfo{ + "value": {}, + }, + }, + "Rest$ConsumedODataService": { + Properties: map[string]version.PropertyVersionInfo{ + "configurationMicroflow": {Introduced: "10.12.0"}, + "errorHandlingMicroflow": {Introduced: "9.6.0"}, + "headersMicroflow": {Introduced: "8.4.0", Deleted: "10.12.0"}, + "httpConfiguration": {Introduced: "8.0.0", Required: true}, + "lastUpdated": {Introduced: "8.14.0", Public: true}, + "metadataReferences": {Introduced: "8.6.0"}, + "oDataVersion": {Introduced: "8.6.0"}, + "serviceId": {Introduced: "8.0.0", Deleted: "8.14.0"}, + "timeoutExpression": {Introduced: "8.5.0"}, + "timeoutModel": {Introduced: "8.5.0", Deleted: "9.8.0", Required: true}, + "useQuerySegment": {Introduced: "9.6.0"}, + "versionApiMockResults": {Introduced: "8.13.0", Deleted: "8.14.0"}, + }, + }, + "Rest$ConsumedRestService": { + Properties: map[string]version.PropertyVersionInfo{ + "authenticationScheme": {Introduced: "10.2.0"}, + "baseUrl": {Required: true}, + "baseUrlParameter": {Introduced: "10.17.0", Public: true}, + "openApiFile": {Introduced: "10.21.0"}, + "operations": {Public: true}, + }, + }, + "Rest$HeaderWithValueTemplate": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "value": {Required: true}, + }, + }, + "Rest$ImplicitMappingBody": { + Properties: map[string]version.PropertyVersionInfo{ + "rootMappingElement": {Required: true}, + "testValue": {Required: true}, + }, + }, + "Rest$ImplicitMappingResponseHandling": { + Properties: map[string]version.PropertyVersionInfo{ + "rootMappingElement": {Required: true}, + }, + }, + "Rest$MetadataReference": { + Properties: map[string]version.PropertyVersionInfo{ + "metadataReferences": {Introduced: "8.8.0"}, + }, + }, + "Rest$ODataEntityTypeSource": { + Properties: map[string]version.PropertyVersionInfo{ + "isOpen": {Introduced: "11.5.0"}, + "key": {Public: true}, + }, + }, + "Rest$ODataKey": { + Properties: map[string]version.PropertyVersionInfo{ + "parts": {Public: true}, + }, + }, + "Rest$ODataKeyPart": { + Properties: map[string]version.PropertyVersionInfo{ + "filterable": {Introduced: "9.16.0"}, + "remoteType": {Introduced: "9.9.0"}, + "type": {Required: true, Public: true}, + }, + }, + "Rest$ODataMappedValue": { + Properties: map[string]version.PropertyVersionInfo{ + "creatable": {Introduced: "9.11.0"}, + "filterable": {Introduced: "8.16.0", Public: true}, + "remoteType": {Introduced: "8.15.0"}, + "representsStream": {Introduced: "9.11.0", Public: true}, + "sortable": {Introduced: "8.16.0", Public: true}, + "updatable": {Introduced: "9.6.0"}, + }, + }, + "Rest$ODataRemoteAssociationSource": { + Properties: map[string]version.PropertyVersionInfo{ + "creatableFromChild": {Introduced: "9.11.0"}, + "creatableFromParent": {Introduced: "9.11.0"}, + "navigability": {Introduced: "8.16.0", Deleted: "9.14.0"}, + "navigability2": {Introduced: "9.14.0"}, + "updatableFromChild": {Introduced: "9.6.0"}, + "updatableFromParent": {Introduced: "9.6.0"}, + }, + }, + "Rest$ODataRemoteEntitySource": { + Properties: map[string]version.PropertyVersionInfo{ + "countable": {Introduced: "8.16.0", Public: true}, + "creatable": {Introduced: "9.11.0"}, + "createChangeLocally": {Introduced: "10.4.0"}, + "deletable": {Introduced: "9.11.0"}, + "entitySet": {Introduced: "8.11.0", Deleted: "9.5.0"}, + "entitySetName": {Introduced: "9.5.0"}, + "entityTypeName": {Introduced: "9.5.0"}, + "key": {Introduced: "8.11.0", Public: true}, + "remoteName": {Deleted: "9.5.0"}, + "skipSupported": {Introduced: "9.21.0"}, + "topSupported": {Introduced: "9.21.0"}, + }, + }, + "Rest$OperationParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "dataType": {Required: true}, + "name": {Public: true}, + "testValue": {Required: true}, + }, + }, + "Rest$PublishedODataContract": { + Properties: map[string]version.PropertyVersionInfo{ + "openApi": {Introduced: "9.17.0"}, + "serviceFeed": {Required: true}, + }, + }, + "Rest$PublishedODataEnumeration": { + Properties: map[string]version.PropertyVersionInfo{ + "enumeration": {Required: true}, + }, + }, + "Rest$PublishedODataEnumerationValue": { + Properties: map[string]version.PropertyVersionInfo{ + "enumerationValue": {Required: true}, + }, + }, + "Rest$PublishedODataMicroflow": { + Properties: map[string]version.PropertyVersionInfo{ + "microflow": {Required: true}, + "parameters": {Introduced: "10.0.0"}, + "returnType": {Introduced: "10.2.0", Required: true}, + }, + }, + "Rest$PublishedODataMicroflowParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "dataType": {Introduced: "10.2.0", Required: true}, + "microflowParameter": {Required: true}, + "type": {Deleted: "10.2.0", Required: true}, + }, + }, + "Rest$PublishedODataService": { + Properties: map[string]version.PropertyVersionInfo{ + "authenticationMicroflow": {Introduced: "8.0.0"}, + "authenticationTypes": {Introduced: "8.0.0"}, + "description": {Introduced: "8.4.0"}, + "enumerations": {Introduced: "9.21.0"}, + "microflows": {Introduced: "9.19.0"}, + "oDataVersion": {Introduced: "9.1.0"}, + "publishAssociations": {Introduced: "7.19.0"}, + "replaceIllegalChars": {Introduced: "8.12.0"}, + "serviceName": {Introduced: "8.0.0"}, + "summary": {Introduced: "8.4.0"}, + "useGeneralization": {Introduced: "8.18.0"}, + "version": {Introduced: "8.0.0"}, + }, + }, + "Rest$PublishedRestResource": { + Properties: map[string]version.PropertyVersionInfo{ + "countMicroflow": {Introduced: "9.9.0", Deleted: "9.14.0"}, + "deletable": {Introduced: "9.10.0", Deleted: "9.11.0"}, + "deleteMode": {Introduced: "9.11.0", Required: true}, + "description": {Introduced: "8.0.0"}, + "exposedName": {Introduced: "7.19.0"}, + "insertMode": {Introduced: "9.11.0", Required: true}, + "insertable": {Introduced: "9.10.0", Deleted: "9.11.0"}, + "queryMicroflow": {Introduced: "9.9.0", Deleted: "9.14.0"}, + "queryOptions": {Introduced: "9.17.0", Required: true}, + "readMode": {Introduced: "9.14.0", Required: true}, + "summary": {Introduced: "8.0.0"}, + "updatable": {Introduced: "9.4.0", Deleted: "9.11.0"}, + "updateMicroflow": {Introduced: "9.9.0", Deleted: "9.11.0"}, + "updateMode": {Introduced: "9.11.0", Required: true}, + }, + }, + "Rest$PublishedRestService": { + Properties: map[string]version.PropertyVersionInfo{ + "authenticationMicroflow": {Introduced: "7.17.0"}, + "authenticationType": {Introduced: "7.11.0", Deleted: "7.13.0"}, + "authenticationTypes": {Introduced: "7.13.0"}, + "corsConfiguration": {Introduced: "7.18.0"}, + "parameters": {Introduced: "7.17.0"}, + "resources": {Introduced: "7.7.0"}, + "serviceName": {Introduced: "7.12.0"}, + "version": {Introduced: "7.12.0"}, + }, + }, + "Rest$PublishedRestServiceOperation": { + Properties: map[string]version.PropertyVersionInfo{ + "commit": {Introduced: "7.14.0"}, + "deprecated": {Introduced: "7.15.0"}, + "exportMapping": {Introduced: "7.14.0"}, + "importMapping": {Introduced: "7.14.0"}, + "objectHandlingBackup": {Introduced: "7.17.0"}, + "parameters": {Introduced: "7.17.0"}, + }, + }, + "Rest$QueryOptions": { + Properties: map[string]version.PropertyVersionInfo{ + "skipSupported": {Introduced: "9.19.0"}, + "topSupported": {Introduced: "9.19.0"}, + }, + }, + "Rest$QueryParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + "parameterUsage": {Required: true}, + }, + }, + "Rest$RestOperation": { + Properties: map[string]version.PropertyVersionInfo{ + "headers": {Public: true}, + "method": {Introduced: "10.4.0", Required: true}, + "name": {Public: true}, + "parameters": {Public: true}, + "path": {Required: true}, + "queryParameters": {Introduced: "11.0.0", Public: true}, + "responseHandling": {Introduced: "10.3.0", Required: true}, + "tags": {Introduced: "10.21.0"}, + }, + }, + "Rest$RestOperationMethodWithBody": { + Properties: map[string]version.PropertyVersionInfo{ + "body": {Required: true}, + }, + }, + "Rest$RestOperationParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "dataType": {Deleted: "7.9.0", Required: true}, + "description": {Introduced: "8.3.0"}, + "microflowParameter": {Introduced: "7.17.0"}, + "type": {Introduced: "7.17.0", Required: true}, + }, + }, + "Rest$RestParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "dataType": {Required: true}, + "name": {Public: true}, + "testValue": {Required: true}, + }, + }, + "Rest$StringBody": { + Properties: map[string]version.PropertyVersionInfo{ + "value": {Deleted: "10.11.0"}, + "valueTemplate": {Introduced: "10.11.0", Required: true}, + }, + }, +} diff --git a/modelsdk/gen/scheduledevents/enums.go b/modelsdk/gen/scheduledevents/enums.go new file mode 100644 index 00000000..700f93ff --- /dev/null +++ b/modelsdk/gen/scheduledevents/enums.go @@ -0,0 +1,58 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package scheduledevents + +// DaySelector enumerates the possible values for the DaySelector type. +type DaySelector = string + +const ( + DaySelectorFirst DaySelector = "First" + DaySelectorSecond DaySelector = "Second" + DaySelectorThird DaySelector = "Third" + DaySelectorFourth DaySelector = "Fourth" + DaySelectorLast DaySelector = "Last" +) + +// IntervalType enumerates the possible values for the IntervalType type. +type IntervalType = string + +const ( + IntervalTypeSecond IntervalType = "Second" + IntervalTypeMinute IntervalType = "Minute" + IntervalTypeHour IntervalType = "Hour" + IntervalTypeDay IntervalType = "Day" + IntervalTypeWeek IntervalType = "Week" + IntervalTypeMonth IntervalType = "Month" + IntervalTypeYear IntervalType = "Year" +) + +// OverlapStrategy enumerates the possible values for the OverlapStrategy type. +type OverlapStrategy = string + +const ( + OverlapStrategySkipNext OverlapStrategy = "SkipNext" + OverlapStrategyDelayNext OverlapStrategy = "DelayNext" +) + +// TimeZoneEnum enumerates the possible values for the TimeZoneEnum type. +type TimeZoneEnum = string + +const ( + TimeZoneEnumUTC TimeZoneEnum = "UTC" + TimeZoneEnumServer TimeZoneEnum = "Server" +) + +// Weekday enumerates the possible values for the Weekday type. +type Weekday = string + +const ( + WeekdaySunday Weekday = "Sunday" + WeekdayMonday Weekday = "Monday" + WeekdayTuesday Weekday = "Tuesday" + WeekdayWednesday Weekday = "Wednesday" + WeekdayThursday Weekday = "Thursday" + WeekdayFriday Weekday = "Friday" + WeekdaySaturday Weekday = "Saturday" +) diff --git a/modelsdk/gen/scheduledevents/refs.go b/modelsdk/gen/scheduledevents/refs.go new file mode 100644 index 00000000..409cae0c --- /dev/null +++ b/modelsdk/gen/scheduledevents/refs.go @@ -0,0 +1,13 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package scheduledevents + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("ScheduledEvents$ScheduledEvent", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) +} diff --git a/modelsdk/gen/scheduledevents/types.go b/modelsdk/gen/scheduledevents/types.go new file mode 100644 index 00000000..9a380523 --- /dev/null +++ b/modelsdk/gen/scheduledevents/types.go @@ -0,0 +1,1135 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package scheduledevents + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Schedule +// ──────────────────────────────────────────────────────── + +type Schedule struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Schedule) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// DaySchedule +// ──────────────────────────────────────────────────────── + +type DaySchedule struct { + element.Base + hourOfDay *property.Primitive[int32] + minuteOfHour *property.Primitive[int32] +} + +// HourOfDay returns the value of the hourOfDay property. +func (o *DaySchedule) HourOfDay() int32 { + return o.hourOfDay.Get() +} + +// SetHourOfDay sets the value of the hourOfDay property. +func (o *DaySchedule) SetHourOfDay(v int32) { + o.hourOfDay.Set(v) +} + +// MinuteOfHour returns the value of the minuteOfHour property. +func (o *DaySchedule) MinuteOfHour() int32 { + return o.minuteOfHour.Get() +} + +// SetMinuteOfHour sets the value of the minuteOfHour property. +func (o *DaySchedule) SetMinuteOfHour(v int32) { + o.minuteOfHour.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DaySchedule) InitFromRaw(raw bson.Raw) { + o.hourOfDay.Init(raw) + o.minuteOfHour.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// HourSchedule +// ──────────────────────────────────────────────────────── + +type HourSchedule struct { + element.Base + multiplier *property.Primitive[int32] + minuteOffset *property.Primitive[int32] +} + +// Multiplier returns the value of the multiplier property. +func (o *HourSchedule) Multiplier() int32 { + return o.multiplier.Get() +} + +// SetMultiplier sets the value of the multiplier property. +func (o *HourSchedule) SetMultiplier(v int32) { + o.multiplier.Set(v) +} + +// MinuteOffset returns the value of the minuteOffset property. +func (o *HourSchedule) MinuteOffset() int32 { + return o.minuteOffset.Get() +} + +// SetMinuteOffset sets the value of the minuteOffset property. +func (o *HourSchedule) SetMinuteOffset(v int32) { + o.minuteOffset.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *HourSchedule) InitFromRaw(raw bson.Raw) { + o.multiplier.Init(raw) + o.minuteOffset.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MinuteSchedule +// ──────────────────────────────────────────────────────── + +type MinuteSchedule struct { + element.Base + multiplier *property.Primitive[int32] +} + +// Multiplier returns the value of the multiplier property. +func (o *MinuteSchedule) Multiplier() int32 { + return o.multiplier.Get() +} + +// SetMultiplier sets the value of the multiplier property. +func (o *MinuteSchedule) SetMultiplier(v int32) { + o.multiplier.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MinuteSchedule) InitFromRaw(raw bson.Raw) { + o.multiplier.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MonthSchedule +// ──────────────────────────────────────────────────────── + +type MonthSchedule struct { + element.Base + multiplier *property.Primitive[int32] + monthOffset *property.Primitive[int32] + hourOfDay *property.Primitive[int32] + minuteOfHour *property.Primitive[int32] +} + +// Multiplier returns the value of the multiplier property. +func (o *MonthSchedule) Multiplier() int32 { + return o.multiplier.Get() +} + +// SetMultiplier sets the value of the multiplier property. +func (o *MonthSchedule) SetMultiplier(v int32) { + o.multiplier.Set(v) +} + +// MonthOffset returns the value of the monthOffset property. +func (o *MonthSchedule) MonthOffset() int32 { + return o.monthOffset.Get() +} + +// SetMonthOffset sets the value of the monthOffset property. +func (o *MonthSchedule) SetMonthOffset(v int32) { + o.monthOffset.Set(v) +} + +// HourOfDay returns the value of the hourOfDay property. +func (o *MonthSchedule) HourOfDay() int32 { + return o.hourOfDay.Get() +} + +// SetHourOfDay sets the value of the hourOfDay property. +func (o *MonthSchedule) SetHourOfDay(v int32) { + o.hourOfDay.Set(v) +} + +// MinuteOfHour returns the value of the minuteOfHour property. +func (o *MonthSchedule) MinuteOfHour() int32 { + return o.minuteOfHour.Get() +} + +// SetMinuteOfHour sets the value of the minuteOfHour property. +func (o *MonthSchedule) SetMinuteOfHour(v int32) { + o.minuteOfHour.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MonthSchedule) InitFromRaw(raw bson.Raw) { + o.multiplier.Init(raw) + o.monthOffset.Init(raw) + o.hourOfDay.Init(raw) + o.minuteOfHour.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MonthDateSchedule +// ──────────────────────────────────────────────────────── + +type MonthDateSchedule struct { + element.Base + multiplier *property.Primitive[int32] + monthOffset *property.Primitive[int32] + hourOfDay *property.Primitive[int32] + minuteOfHour *property.Primitive[int32] + dayOfMonth *property.Primitive[int32] +} + +// Multiplier returns the value of the multiplier property. +func (o *MonthDateSchedule) Multiplier() int32 { + return o.multiplier.Get() +} + +// SetMultiplier sets the value of the multiplier property. +func (o *MonthDateSchedule) SetMultiplier(v int32) { + o.multiplier.Set(v) +} + +// MonthOffset returns the value of the monthOffset property. +func (o *MonthDateSchedule) MonthOffset() int32 { + return o.monthOffset.Get() +} + +// SetMonthOffset sets the value of the monthOffset property. +func (o *MonthDateSchedule) SetMonthOffset(v int32) { + o.monthOffset.Set(v) +} + +// HourOfDay returns the value of the hourOfDay property. +func (o *MonthDateSchedule) HourOfDay() int32 { + return o.hourOfDay.Get() +} + +// SetHourOfDay sets the value of the hourOfDay property. +func (o *MonthDateSchedule) SetHourOfDay(v int32) { + o.hourOfDay.Set(v) +} + +// MinuteOfHour returns the value of the minuteOfHour property. +func (o *MonthDateSchedule) MinuteOfHour() int32 { + return o.minuteOfHour.Get() +} + +// SetMinuteOfHour sets the value of the minuteOfHour property. +func (o *MonthDateSchedule) SetMinuteOfHour(v int32) { + o.minuteOfHour.Set(v) +} + +// DayOfMonth returns the value of the dayOfMonth property. +func (o *MonthDateSchedule) DayOfMonth() int32 { + return o.dayOfMonth.Get() +} + +// SetDayOfMonth sets the value of the dayOfMonth property. +func (o *MonthDateSchedule) SetDayOfMonth(v int32) { + o.dayOfMonth.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MonthDateSchedule) InitFromRaw(raw bson.Raw) { + o.multiplier.Init(raw) + o.monthOffset.Init(raw) + o.hourOfDay.Init(raw) + o.minuteOfHour.Init(raw) + o.dayOfMonth.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MonthWeekdaySchedule +// ──────────────────────────────────────────────────────── + +type MonthWeekdaySchedule struct { + element.Base + multiplier *property.Primitive[int32] + monthOffset *property.Primitive[int32] + hourOfDay *property.Primitive[int32] + minuteOfHour *property.Primitive[int32] + daySelector *property.Enum[string] + weekday *property.Enum[string] +} + +// Multiplier returns the value of the multiplier property. +func (o *MonthWeekdaySchedule) Multiplier() int32 { + return o.multiplier.Get() +} + +// SetMultiplier sets the value of the multiplier property. +func (o *MonthWeekdaySchedule) SetMultiplier(v int32) { + o.multiplier.Set(v) +} + +// MonthOffset returns the value of the monthOffset property. +func (o *MonthWeekdaySchedule) MonthOffset() int32 { + return o.monthOffset.Get() +} + +// SetMonthOffset sets the value of the monthOffset property. +func (o *MonthWeekdaySchedule) SetMonthOffset(v int32) { + o.monthOffset.Set(v) +} + +// HourOfDay returns the value of the hourOfDay property. +func (o *MonthWeekdaySchedule) HourOfDay() int32 { + return o.hourOfDay.Get() +} + +// SetHourOfDay sets the value of the hourOfDay property. +func (o *MonthWeekdaySchedule) SetHourOfDay(v int32) { + o.hourOfDay.Set(v) +} + +// MinuteOfHour returns the value of the minuteOfHour property. +func (o *MonthWeekdaySchedule) MinuteOfHour() int32 { + return o.minuteOfHour.Get() +} + +// SetMinuteOfHour sets the value of the minuteOfHour property. +func (o *MonthWeekdaySchedule) SetMinuteOfHour(v int32) { + o.minuteOfHour.Set(v) +} + +// DaySelector returns the value of the daySelector property. +func (o *MonthWeekdaySchedule) DaySelector() string { + return o.daySelector.Get() +} + +// SetDaySelector sets the value of the daySelector property. +func (o *MonthWeekdaySchedule) SetDaySelector(v string) { + o.daySelector.Set(v) +} + +// Weekday returns the value of the weekday property. +func (o *MonthWeekdaySchedule) Weekday() string { + return o.weekday.Get() +} + +// SetWeekday sets the value of the weekday property. +func (o *MonthWeekdaySchedule) SetWeekday(v string) { + o.weekday.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MonthWeekdaySchedule) InitFromRaw(raw bson.Raw) { + o.multiplier.Init(raw) + o.monthOffset.Init(raw) + o.hourOfDay.Init(raw) + o.minuteOfHour.Init(raw) + if val, err := raw.LookupErr("DaySelector"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.daySelector.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Weekday"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.weekday.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// ScheduledEvent +// ──────────────────────────────────────────────────────── + +type ScheduledEvent struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + startDateTime *property.Primitive[string] + timeZone *property.Enum[string] + schedule *property.Part[element.Element] + onOverlap *property.Enum[string] + interval *property.Primitive[int32] + intervalType *property.Enum[string] + microflow *property.ByNameRef[element.Element] + enabled *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *ScheduledEvent) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ScheduledEvent) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ScheduledEvent) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ScheduledEvent) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ScheduledEvent) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ScheduledEvent) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ScheduledEvent) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ScheduledEvent) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// StartDateTime returns the value of the startDateTime property. +func (o *ScheduledEvent) StartDateTime() string { + return o.startDateTime.Get() +} + +// SetStartDateTime sets the value of the startDateTime property. +func (o *ScheduledEvent) SetStartDateTime(v string) { + o.startDateTime.Set(v) +} + +// TimeZone returns the value of the timeZone property. +func (o *ScheduledEvent) TimeZone() string { + return o.timeZone.Get() +} + +// SetTimeZone sets the value of the timeZone property. +func (o *ScheduledEvent) SetTimeZone(v string) { + o.timeZone.Set(v) +} + +// Schedule returns the value of the schedule property. +func (o *ScheduledEvent) Schedule() element.Element { + return o.schedule.Get() +} + +// SetSchedule sets the value of the schedule property. +func (o *ScheduledEvent) SetSchedule(v element.Element) { + o.schedule.Set(v) +} + +// OnOverlap returns the value of the onOverlap property. +func (o *ScheduledEvent) OnOverlap() string { + return o.onOverlap.Get() +} + +// SetOnOverlap sets the value of the onOverlap property. +func (o *ScheduledEvent) SetOnOverlap(v string) { + o.onOverlap.Set(v) +} + +// Interval returns the value of the interval property. +func (o *ScheduledEvent) Interval() int32 { + return o.interval.Get() +} + +// SetInterval sets the value of the interval property. +func (o *ScheduledEvent) SetInterval(v int32) { + o.interval.Set(v) +} + +// IntervalType returns the value of the intervalType property. +func (o *ScheduledEvent) IntervalType() string { + return o.intervalType.Get() +} + +// SetIntervalType sets the value of the intervalType property. +func (o *ScheduledEvent) SetIntervalType(v string) { + o.intervalType.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *ScheduledEvent) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *ScheduledEvent) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// Enabled returns the value of the enabled property. +func (o *ScheduledEvent) Enabled() bool { + return o.enabled.Get() +} + +// SetEnabled sets the value of the enabled property. +func (o *ScheduledEvent) SetEnabled(v bool) { + o.enabled.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ScheduledEvent) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + o.startDateTime.Init(raw) + if val, err := raw.LookupErr("TimeZone"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.timeZone.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "Schedule"); err == nil { + o.schedule.SetFromDecode(child) + } + if val, err := raw.LookupErr("OnOverlap"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.onOverlap.SetFromDecode(s) + } + } + o.interval.Init(raw) + if val, err := raw.LookupErr("IntervalType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.intervalType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + o.enabled.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WeekSchedule +// ──────────────────────────────────────────────────────── + +type WeekSchedule struct { + element.Base + sunday *property.Primitive[bool] + monday *property.Primitive[bool] + tuesday *property.Primitive[bool] + wednesday *property.Primitive[bool] + thursday *property.Primitive[bool] + friday *property.Primitive[bool] + saturday *property.Primitive[bool] + hourOfDay *property.Primitive[int32] + minuteOfHour *property.Primitive[int32] +} + +// Sunday returns the value of the sunday property. +func (o *WeekSchedule) Sunday() bool { + return o.sunday.Get() +} + +// SetSunday sets the value of the sunday property. +func (o *WeekSchedule) SetSunday(v bool) { + o.sunday.Set(v) +} + +// Monday returns the value of the monday property. +func (o *WeekSchedule) Monday() bool { + return o.monday.Get() +} + +// SetMonday sets the value of the monday property. +func (o *WeekSchedule) SetMonday(v bool) { + o.monday.Set(v) +} + +// Tuesday returns the value of the tuesday property. +func (o *WeekSchedule) Tuesday() bool { + return o.tuesday.Get() +} + +// SetTuesday sets the value of the tuesday property. +func (o *WeekSchedule) SetTuesday(v bool) { + o.tuesday.Set(v) +} + +// Wednesday returns the value of the wednesday property. +func (o *WeekSchedule) Wednesday() bool { + return o.wednesday.Get() +} + +// SetWednesday sets the value of the wednesday property. +func (o *WeekSchedule) SetWednesday(v bool) { + o.wednesday.Set(v) +} + +// Thursday returns the value of the thursday property. +func (o *WeekSchedule) Thursday() bool { + return o.thursday.Get() +} + +// SetThursday sets the value of the thursday property. +func (o *WeekSchedule) SetThursday(v bool) { + o.thursday.Set(v) +} + +// Friday returns the value of the friday property. +func (o *WeekSchedule) Friday() bool { + return o.friday.Get() +} + +// SetFriday sets the value of the friday property. +func (o *WeekSchedule) SetFriday(v bool) { + o.friday.Set(v) +} + +// Saturday returns the value of the saturday property. +func (o *WeekSchedule) Saturday() bool { + return o.saturday.Get() +} + +// SetSaturday sets the value of the saturday property. +func (o *WeekSchedule) SetSaturday(v bool) { + o.saturday.Set(v) +} + +// HourOfDay returns the value of the hourOfDay property. +func (o *WeekSchedule) HourOfDay() int32 { + return o.hourOfDay.Get() +} + +// SetHourOfDay sets the value of the hourOfDay property. +func (o *WeekSchedule) SetHourOfDay(v int32) { + o.hourOfDay.Set(v) +} + +// MinuteOfHour returns the value of the minuteOfHour property. +func (o *WeekSchedule) MinuteOfHour() int32 { + return o.minuteOfHour.Get() +} + +// SetMinuteOfHour sets the value of the minuteOfHour property. +func (o *WeekSchedule) SetMinuteOfHour(v int32) { + o.minuteOfHour.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WeekSchedule) InitFromRaw(raw bson.Raw) { + o.sunday.Init(raw) + o.monday.Init(raw) + o.tuesday.Init(raw) + o.wednesday.Init(raw) + o.thursday.Init(raw) + o.friday.Init(raw) + o.saturday.Init(raw) + o.hourOfDay.Init(raw) + o.minuteOfHour.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// YearSchedule +// ──────────────────────────────────────────────────────── + +type YearSchedule struct { + element.Base + month *property.Primitive[int32] + hourOfDay *property.Primitive[int32] + minuteOfHour *property.Primitive[int32] +} + +// Month returns the value of the month property. +func (o *YearSchedule) Month() int32 { + return o.month.Get() +} + +// SetMonth sets the value of the month property. +func (o *YearSchedule) SetMonth(v int32) { + o.month.Set(v) +} + +// HourOfDay returns the value of the hourOfDay property. +func (o *YearSchedule) HourOfDay() int32 { + return o.hourOfDay.Get() +} + +// SetHourOfDay sets the value of the hourOfDay property. +func (o *YearSchedule) SetHourOfDay(v int32) { + o.hourOfDay.Set(v) +} + +// MinuteOfHour returns the value of the minuteOfHour property. +func (o *YearSchedule) MinuteOfHour() int32 { + return o.minuteOfHour.Get() +} + +// SetMinuteOfHour sets the value of the minuteOfHour property. +func (o *YearSchedule) SetMinuteOfHour(v int32) { + o.minuteOfHour.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *YearSchedule) InitFromRaw(raw bson.Raw) { + o.month.Init(raw) + o.hourOfDay.Init(raw) + o.minuteOfHour.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// YearDateSchedule +// ──────────────────────────────────────────────────────── + +type YearDateSchedule struct { + element.Base + month *property.Primitive[int32] + hourOfDay *property.Primitive[int32] + minuteOfHour *property.Primitive[int32] + dayOfMonth *property.Primitive[int32] +} + +// Month returns the value of the month property. +func (o *YearDateSchedule) Month() int32 { + return o.month.Get() +} + +// SetMonth sets the value of the month property. +func (o *YearDateSchedule) SetMonth(v int32) { + o.month.Set(v) +} + +// HourOfDay returns the value of the hourOfDay property. +func (o *YearDateSchedule) HourOfDay() int32 { + return o.hourOfDay.Get() +} + +// SetHourOfDay sets the value of the hourOfDay property. +func (o *YearDateSchedule) SetHourOfDay(v int32) { + o.hourOfDay.Set(v) +} + +// MinuteOfHour returns the value of the minuteOfHour property. +func (o *YearDateSchedule) MinuteOfHour() int32 { + return o.minuteOfHour.Get() +} + +// SetMinuteOfHour sets the value of the minuteOfHour property. +func (o *YearDateSchedule) SetMinuteOfHour(v int32) { + o.minuteOfHour.Set(v) +} + +// DayOfMonth returns the value of the dayOfMonth property. +func (o *YearDateSchedule) DayOfMonth() int32 { + return o.dayOfMonth.Get() +} + +// SetDayOfMonth sets the value of the dayOfMonth property. +func (o *YearDateSchedule) SetDayOfMonth(v int32) { + o.dayOfMonth.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *YearDateSchedule) InitFromRaw(raw bson.Raw) { + o.month.Init(raw) + o.hourOfDay.Init(raw) + o.minuteOfHour.Init(raw) + o.dayOfMonth.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// YearWeekdaySchedule +// ──────────────────────────────────────────────────────── + +type YearWeekdaySchedule struct { + element.Base + month *property.Primitive[int32] + hourOfDay *property.Primitive[int32] + minuteOfHour *property.Primitive[int32] + daySelector *property.Enum[string] + weekday *property.Enum[string] +} + +// Month returns the value of the month property. +func (o *YearWeekdaySchedule) Month() int32 { + return o.month.Get() +} + +// SetMonth sets the value of the month property. +func (o *YearWeekdaySchedule) SetMonth(v int32) { + o.month.Set(v) +} + +// HourOfDay returns the value of the hourOfDay property. +func (o *YearWeekdaySchedule) HourOfDay() int32 { + return o.hourOfDay.Get() +} + +// SetHourOfDay sets the value of the hourOfDay property. +func (o *YearWeekdaySchedule) SetHourOfDay(v int32) { + o.hourOfDay.Set(v) +} + +// MinuteOfHour returns the value of the minuteOfHour property. +func (o *YearWeekdaySchedule) MinuteOfHour() int32 { + return o.minuteOfHour.Get() +} + +// SetMinuteOfHour sets the value of the minuteOfHour property. +func (o *YearWeekdaySchedule) SetMinuteOfHour(v int32) { + o.minuteOfHour.Set(v) +} + +// DaySelector returns the value of the daySelector property. +func (o *YearWeekdaySchedule) DaySelector() string { + return o.daySelector.Get() +} + +// SetDaySelector sets the value of the daySelector property. +func (o *YearWeekdaySchedule) SetDaySelector(v string) { + o.daySelector.Set(v) +} + +// Weekday returns the value of the weekday property. +func (o *YearWeekdaySchedule) Weekday() string { + return o.weekday.Get() +} + +// SetWeekday sets the value of the weekday property. +func (o *YearWeekdaySchedule) SetWeekday(v string) { + o.weekday.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *YearWeekdaySchedule) InitFromRaw(raw bson.Raw) { + o.month.Init(raw) + o.hourOfDay.Init(raw) + o.minuteOfHour.Init(raw) + if val, err := raw.LookupErr("DaySelector"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.daySelector.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Weekday"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.weekday.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initDaySchedule creates a DaySchedule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDaySchedule() *DaySchedule { + o := &DaySchedule{} + o.SetTypeName("ScheduledEvents$DaySchedule") + o.hourOfDay = property.NewPrimitive[int32]("HourOfDay", property.DecodeInt32) + o.hourOfDay.Bind(&o.Base, 0) + o.minuteOfHour = property.NewPrimitive[int32]("MinuteOfHour", property.DecodeInt32) + o.minuteOfHour.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.hourOfDay, o.minuteOfHour}) + return o +} + +// NewDaySchedule creates a new DaySchedule for user code. Marked dirty (bit 63 = new element). +func NewDaySchedule() *DaySchedule { + o := initDaySchedule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initHourSchedule creates a HourSchedule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initHourSchedule() *HourSchedule { + o := &HourSchedule{} + o.SetTypeName("ScheduledEvents$HourSchedule") + o.multiplier = property.NewPrimitive[int32]("Multiplier", property.DecodeInt32) + o.multiplier.Bind(&o.Base, 0) + o.minuteOffset = property.NewPrimitive[int32]("MinuteOffset", property.DecodeInt32) + o.minuteOffset.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.multiplier, o.minuteOffset}) + return o +} + +// NewHourSchedule creates a new HourSchedule for user code. Marked dirty (bit 63 = new element). +func NewHourSchedule() *HourSchedule { + o := initHourSchedule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMinuteSchedule creates a MinuteSchedule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMinuteSchedule() *MinuteSchedule { + o := &MinuteSchedule{} + o.SetTypeName("ScheduledEvents$MinuteSchedule") + o.multiplier = property.NewPrimitive[int32]("Multiplier", property.DecodeInt32) + o.multiplier.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.multiplier}) + return o +} + +// NewMinuteSchedule creates a new MinuteSchedule for user code. Marked dirty (bit 63 = new element). +func NewMinuteSchedule() *MinuteSchedule { + o := initMinuteSchedule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMonthDateSchedule creates a MonthDateSchedule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMonthDateSchedule() *MonthDateSchedule { + o := &MonthDateSchedule{} + o.SetTypeName("ScheduledEvents$MonthDateSchedule") + o.multiplier = property.NewPrimitive[int32]("Multiplier", property.DecodeInt32) + o.multiplier.Bind(&o.Base, 0) + o.monthOffset = property.NewPrimitive[int32]("MonthOffset", property.DecodeInt32) + o.monthOffset.Bind(&o.Base, 1) + o.hourOfDay = property.NewPrimitive[int32]("HourOfDay", property.DecodeInt32) + o.hourOfDay.Bind(&o.Base, 2) + o.minuteOfHour = property.NewPrimitive[int32]("MinuteOfHour", property.DecodeInt32) + o.minuteOfHour.Bind(&o.Base, 3) + o.dayOfMonth = property.NewPrimitive[int32]("DayOfMonth", property.DecodeInt32) + o.dayOfMonth.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.multiplier, o.monthOffset, o.hourOfDay, o.minuteOfHour, o.dayOfMonth}) + return o +} + +// NewMonthDateSchedule creates a new MonthDateSchedule for user code. Marked dirty (bit 63 = new element). +func NewMonthDateSchedule() *MonthDateSchedule { + o := initMonthDateSchedule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMonthWeekdaySchedule creates a MonthWeekdaySchedule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMonthWeekdaySchedule() *MonthWeekdaySchedule { + o := &MonthWeekdaySchedule{} + o.SetTypeName("ScheduledEvents$MonthWeekdaySchedule") + o.multiplier = property.NewPrimitive[int32]("Multiplier", property.DecodeInt32) + o.multiplier.Bind(&o.Base, 0) + o.monthOffset = property.NewPrimitive[int32]("MonthOffset", property.DecodeInt32) + o.monthOffset.Bind(&o.Base, 1) + o.hourOfDay = property.NewPrimitive[int32]("HourOfDay", property.DecodeInt32) + o.hourOfDay.Bind(&o.Base, 2) + o.minuteOfHour = property.NewPrimitive[int32]("MinuteOfHour", property.DecodeInt32) + o.minuteOfHour.Bind(&o.Base, 3) + o.daySelector = property.NewEnum[string]("DaySelector") + o.daySelector.Bind(&o.Base, 4) + o.weekday = property.NewEnum[string]("Weekday") + o.weekday.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.multiplier, o.monthOffset, o.hourOfDay, o.minuteOfHour, o.daySelector, o.weekday}) + return o +} + +// NewMonthWeekdaySchedule creates a new MonthWeekdaySchedule for user code. Marked dirty (bit 63 = new element). +func NewMonthWeekdaySchedule() *MonthWeekdaySchedule { + o := initMonthWeekdaySchedule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initScheduledEvent creates a ScheduledEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initScheduledEvent() *ScheduledEvent { + o := &ScheduledEvent{} + o.SetTypeName("ScheduledEvents$ScheduledEvent") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.startDateTime = property.NewPrimitive[string]("StartDateTime", property.DecodeString) + o.startDateTime.Bind(&o.Base, 4) + o.timeZone = property.NewEnum[string]("TimeZone") + o.timeZone.Bind(&o.Base, 5) + o.schedule = property.NewPart[element.Element]("Schedule") + o.schedule.Bind(&o.Base, 6) + o.onOverlap = property.NewEnum[string]("OnOverlap") + o.onOverlap.Bind(&o.Base, 7) + o.interval = property.NewPrimitive[int32]("Interval", property.DecodeInt32) + o.interval.Bind(&o.Base, 8) + o.intervalType = property.NewEnum[string]("IntervalType") + o.intervalType.Bind(&o.Base, 9) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 10) + o.enabled = property.NewPrimitive[bool]("Enabled", property.DecodeBool) + o.enabled.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.startDateTime, o.timeZone, o.schedule, o.onOverlap, o.interval, o.intervalType, o.microflow, o.enabled}) + return o +} + +// NewScheduledEvent creates a new ScheduledEvent for user code. Marked dirty (bit 63 = new element). +func NewScheduledEvent() *ScheduledEvent { + o := initScheduledEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWeekSchedule creates a WeekSchedule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWeekSchedule() *WeekSchedule { + o := &WeekSchedule{} + o.SetTypeName("ScheduledEvents$WeekSchedule") + o.sunday = property.NewPrimitive[bool]("Sunday", property.DecodeBool) + o.sunday.Bind(&o.Base, 0) + o.monday = property.NewPrimitive[bool]("Monday", property.DecodeBool) + o.monday.Bind(&o.Base, 1) + o.tuesday = property.NewPrimitive[bool]("Tuesday", property.DecodeBool) + o.tuesday.Bind(&o.Base, 2) + o.wednesday = property.NewPrimitive[bool]("Wednesday", property.DecodeBool) + o.wednesday.Bind(&o.Base, 3) + o.thursday = property.NewPrimitive[bool]("Thursday", property.DecodeBool) + o.thursday.Bind(&o.Base, 4) + o.friday = property.NewPrimitive[bool]("Friday", property.DecodeBool) + o.friday.Bind(&o.Base, 5) + o.saturday = property.NewPrimitive[bool]("Saturday", property.DecodeBool) + o.saturday.Bind(&o.Base, 6) + o.hourOfDay = property.NewPrimitive[int32]("HourOfDay", property.DecodeInt32) + o.hourOfDay.Bind(&o.Base, 7) + o.minuteOfHour = property.NewPrimitive[int32]("MinuteOfHour", property.DecodeInt32) + o.minuteOfHour.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.sunday, o.monday, o.tuesday, o.wednesday, o.thursday, o.friday, o.saturday, o.hourOfDay, o.minuteOfHour}) + return o +} + +// NewWeekSchedule creates a new WeekSchedule for user code. Marked dirty (bit 63 = new element). +func NewWeekSchedule() *WeekSchedule { + o := initWeekSchedule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initYearDateSchedule creates a YearDateSchedule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initYearDateSchedule() *YearDateSchedule { + o := &YearDateSchedule{} + o.SetTypeName("ScheduledEvents$YearDateSchedule") + o.month = property.NewPrimitive[int32]("Month", property.DecodeInt32) + o.month.Bind(&o.Base, 0) + o.hourOfDay = property.NewPrimitive[int32]("HourOfDay", property.DecodeInt32) + o.hourOfDay.Bind(&o.Base, 1) + o.minuteOfHour = property.NewPrimitive[int32]("MinuteOfHour", property.DecodeInt32) + o.minuteOfHour.Bind(&o.Base, 2) + o.dayOfMonth = property.NewPrimitive[int32]("DayOfMonth", property.DecodeInt32) + o.dayOfMonth.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.month, o.hourOfDay, o.minuteOfHour, o.dayOfMonth}) + return o +} + +// NewYearDateSchedule creates a new YearDateSchedule for user code. Marked dirty (bit 63 = new element). +func NewYearDateSchedule() *YearDateSchedule { + o := initYearDateSchedule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initYearWeekdaySchedule creates a YearWeekdaySchedule with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initYearWeekdaySchedule() *YearWeekdaySchedule { + o := &YearWeekdaySchedule{} + o.SetTypeName("ScheduledEvents$YearWeekdaySchedule") + o.month = property.NewPrimitive[int32]("Month", property.DecodeInt32) + o.month.Bind(&o.Base, 0) + o.hourOfDay = property.NewPrimitive[int32]("HourOfDay", property.DecodeInt32) + o.hourOfDay.Bind(&o.Base, 1) + o.minuteOfHour = property.NewPrimitive[int32]("MinuteOfHour", property.DecodeInt32) + o.minuteOfHour.Bind(&o.Base, 2) + o.daySelector = property.NewEnum[string]("DaySelector") + o.daySelector.Bind(&o.Base, 3) + o.weekday = property.NewEnum[string]("Weekday") + o.weekday.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.month, o.hourOfDay, o.minuteOfHour, o.daySelector, o.weekday}) + return o +} + +// NewYearWeekdaySchedule creates a new YearWeekdaySchedule for user code. Marked dirty (bit 63 = new element). +func NewYearWeekdaySchedule() *YearWeekdaySchedule { + o := initYearWeekdaySchedule() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("ScheduledEvents$DaySchedule", func() element.Element { + return initDaySchedule() + }) + codec.DefaultRegistry.Register("ScheduledEvents$HourSchedule", func() element.Element { + return initHourSchedule() + }) + codec.DefaultRegistry.Register("ScheduledEvents$MinuteSchedule", func() element.Element { + return initMinuteSchedule() + }) + codec.DefaultRegistry.Register("ScheduledEvents$MonthDateSchedule", func() element.Element { + return initMonthDateSchedule() + }) + codec.DefaultRegistry.Register("ScheduledEvents$MonthWeekdaySchedule", func() element.Element { + return initMonthWeekdaySchedule() + }) + codec.DefaultRegistry.Register("ScheduledEvents$ScheduledEvent", func() element.Element { + return initScheduledEvent() + }) + codec.DefaultRegistry.Register("ScheduledEvents$WeekSchedule", func() element.Element { + return initWeekSchedule() + }) + codec.DefaultRegistry.Register("ScheduledEvents$YearDateSchedule", func() element.Element { + return initYearDateSchedule() + }) + codec.DefaultRegistry.Register("ScheduledEvents$YearWeekdaySchedule", func() element.Element { + return initYearWeekdaySchedule() + }) +} diff --git a/modelsdk/gen/scheduledevents/version.go b/modelsdk/gen/scheduledevents/version.go new file mode 100644 index 00000000..53eebef7 --- /dev/null +++ b/modelsdk/gen/scheduledevents/version.go @@ -0,0 +1,17 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package scheduledevents + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "ScheduledEvents$ScheduledEvent": { + Properties: map[string]version.PropertyVersionInfo{ + "onOverlap": {Introduced: "9.12.0"}, + "schedule": {Introduced: "9.12.0"}, + }, + }, +} diff --git a/modelsdk/gen/security/enums.go b/modelsdk/gen/security/enums.go new file mode 100644 index 00000000..b450b9b8 --- /dev/null +++ b/modelsdk/gen/security/enums.go @@ -0,0 +1,14 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package security + +// SecurityLevel enumerates the possible values for the SecurityLevel type. +type SecurityLevel = string + +const ( + SecurityLevelCheckNothing SecurityLevel = "CheckNothing" + SecurityLevelCheckFormsAndMicroflows SecurityLevel = "CheckFormsAndMicroflows" + SecurityLevelCheckEverything SecurityLevel = "CheckEverything" +) diff --git a/modelsdk/gen/security/refs.go b/modelsdk/gen/security/refs.go new file mode 100644 index 00000000..f1e871ba --- /dev/null +++ b/modelsdk/gen/security/refs.go @@ -0,0 +1,25 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package security + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Security$DemoUser", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "UserRoles", Kind: codec.RefByNameList, Target: "Security$UserRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Security$DemoUserImpl", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "UserRoles", Kind: codec.RefByNameList, Target: "Security$UserRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Security$ProjectSecurity", []codec.RefMeta{ + {Prop: "SignInMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Security$UserRole", []codec.RefMeta{ + {Prop: "ModuleRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + {Prop: "ManageableRoles", Kind: codec.RefByNameList, Target: "Security$UserRole"}, + }) +} diff --git a/modelsdk/gen/security/types.go b/modelsdk/gen/security/types.go new file mode 100644 index 00000000..5c395f43 --- /dev/null +++ b/modelsdk/gen/security/types.go @@ -0,0 +1,966 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package security + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// AccessRuleContainerBase +// ──────────────────────────────────────────────────────── + +type AccessRuleContainerBase struct { + element.Base + accessRules *property.PartList[element.Element] +} + +// AccessRulesItems returns the value of the accessRules property. +func (o *AccessRuleContainerBase) AccessRulesItems() []element.Element { + return o.accessRules.Items() +} + +// AddAccessRules appends a child element to the accessRules list. +func (o *AccessRuleContainerBase) AddAccessRules(v element.Element) { + o.accessRules.Append(v) +} + +// RemoveAccessRules removes the element at the given index from the accessRules list. +func (o *AccessRuleContainerBase) RemoveAccessRules(index int) { + o.accessRules.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AccessRuleContainerBase) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "AccessRules"); err == nil { + for _, child := range children { + o.accessRules.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// DemoUser +// ──────────────────────────────────────────────────────── + +type DemoUser struct { + element.Base + userName *property.Primitive[string] + password *property.Primitive[string] + entity *property.ByNameRef[element.Element] + userRoles *property.ByNameRefList[element.Element] +} + +// UserName returns the value of the userName property. +func (o *DemoUser) UserName() string { + return o.userName.Get() +} + +// SetUserName sets the value of the userName property. +func (o *DemoUser) SetUserName(v string) { + o.userName.Set(v) +} + +// Password returns the value of the password property. +func (o *DemoUser) Password() string { + return o.password.Get() +} + +// SetPassword sets the value of the password property. +func (o *DemoUser) SetPassword(v string) { + o.password.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *DemoUser) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *DemoUser) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// UserRolesQualifiedNames returns the value of the userRoles property. +func (o *DemoUser) UserRolesQualifiedNames() []string { + return o.userRoles.QualifiedNames() +} + +// SetUserRolesQualifiedNames sets the value of the userRoles property. +func (o *DemoUser) SetUserRolesQualifiedNames(v []string) { + o.userRoles.SetQualifiedNames(v) +} + +// AddUserRoles appends a child element to the userRoles list. +func (o *DemoUser) AddUserRoles(v string) { + o.userRoles.Append(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DemoUser) InitFromRaw(raw bson.Raw) { + o.userName.Init(raw) + o.password.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("UserRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { + qnames = append(qnames, s) + } + } + o.userRoles.SetFromDecode(qnames) + } + } +} + +// ──────────────────────────────────────────────────────── +// FileDocumentAccessRuleContainer +// ──────────────────────────────────────────────────────── + +type FileDocumentAccessRuleContainer struct { + element.Base + accessRules *property.PartList[element.Element] +} + +// AccessRulesItems returns the value of the accessRules property. +func (o *FileDocumentAccessRuleContainer) AccessRulesItems() []element.Element { + return o.accessRules.Items() +} + +// AddAccessRules appends a child element to the accessRules list. +func (o *FileDocumentAccessRuleContainer) AddAccessRules(v element.Element) { + o.accessRules.Append(v) +} + +// RemoveAccessRules removes the element at the given index from the accessRules list. +func (o *FileDocumentAccessRuleContainer) RemoveAccessRules(index int) { + o.accessRules.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FileDocumentAccessRuleContainer) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "AccessRules"); err == nil { + for _, child := range children { + o.accessRules.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ImageAccessRuleContainer +// ──────────────────────────────────────────────────────── + +type ImageAccessRuleContainer struct { + element.Base + accessRules *property.PartList[element.Element] +} + +// AccessRulesItems returns the value of the accessRules property. +func (o *ImageAccessRuleContainer) AccessRulesItems() []element.Element { + return o.accessRules.Items() +} + +// AddAccessRules appends a child element to the accessRules list. +func (o *ImageAccessRuleContainer) AddAccessRules(v element.Element) { + o.accessRules.Append(v) +} + +// RemoveAccessRules removes the element at the given index from the accessRules list. +func (o *ImageAccessRuleContainer) RemoveAccessRules(index int) { + o.accessRules.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImageAccessRuleContainer) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "AccessRules"); err == nil { + for _, child := range children { + o.accessRules.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ModuleRole +// ──────────────────────────────────────────────────────── + +type ModuleRole struct { + element.Base + name *property.Primitive[string] + description *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *ModuleRole) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ModuleRole) SetName(v string) { + o.name.Set(v) +} + +// Description returns the value of the description property. +func (o *ModuleRole) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *ModuleRole) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ModuleRole) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ModuleSecurity +// ──────────────────────────────────────────────────────── + +type ModuleSecurity struct { + element.Base + moduleRoles *property.PartList[element.Element] +} + +// ModuleRolesItems returns the value of the moduleRoles property. +func (o *ModuleSecurity) ModuleRolesItems() []element.Element { + return o.moduleRoles.Items() +} + +// AddModuleRoles appends a child element to the moduleRoles list. +func (o *ModuleSecurity) AddModuleRoles(v element.Element) { + o.moduleRoles.Append(v) +} + +// RemoveModuleRoles removes the element at the given index from the moduleRoles list. +func (o *ModuleSecurity) RemoveModuleRoles(index int) { + o.moduleRoles.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ModuleSecurity) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "ModuleRoles"); err == nil { + for _, child := range children { + o.moduleRoles.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// PasswordPolicySettings +// ──────────────────────────────────────────────────────── + +type PasswordPolicySettings struct { + element.Base + minimumLength *property.Primitive[int32] + requireMixedCase *property.Primitive[bool] + requireSymbol *property.Primitive[bool] + requireDigit *property.Primitive[bool] +} + +// MinimumLength returns the value of the minimumLength property. +func (o *PasswordPolicySettings) MinimumLength() int32 { + return o.minimumLength.Get() +} + +// SetMinimumLength sets the value of the minimumLength property. +func (o *PasswordPolicySettings) SetMinimumLength(v int32) { + o.minimumLength.Set(v) +} + +// RequireMixedCase returns the value of the requireMixedCase property. +func (o *PasswordPolicySettings) RequireMixedCase() bool { + return o.requireMixedCase.Get() +} + +// SetRequireMixedCase sets the value of the requireMixedCase property. +func (o *PasswordPolicySettings) SetRequireMixedCase(v bool) { + o.requireMixedCase.Set(v) +} + +// RequireSymbol returns the value of the requireSymbol property. +func (o *PasswordPolicySettings) RequireSymbol() bool { + return o.requireSymbol.Get() +} + +// SetRequireSymbol sets the value of the requireSymbol property. +func (o *PasswordPolicySettings) SetRequireSymbol(v bool) { + o.requireSymbol.Set(v) +} + +// RequireDigit returns the value of the requireDigit property. +func (o *PasswordPolicySettings) RequireDigit() bool { + return o.requireDigit.Get() +} + +// SetRequireDigit sets the value of the requireDigit property. +func (o *PasswordPolicySettings) SetRequireDigit(v bool) { + o.requireDigit.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PasswordPolicySettings) InitFromRaw(raw bson.Raw) { + o.minimumLength.Init(raw) + o.requireMixedCase.Init(raw) + o.requireSymbol.Init(raw) + o.requireDigit.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ProjectSecurity +// ──────────────────────────────────────────────────────── + +type ProjectSecurity struct { + element.Base + securityLevel *property.Enum[string] + checkSecurity *property.Primitive[bool] + strictPageUrlCheck *property.Primitive[bool] + userRoles *property.PartList[element.Element] + adminUserName *property.Primitive[string] + adminPassword *property.Primitive[string] + adminUserRoleName *property.Primitive[string] + enableDemoUsers *property.Primitive[bool] + demoUsers *property.PartList[element.Element] + enableGuestAccess *property.Primitive[bool] + guestUserRoleName *property.Primitive[string] + signInMicroflow *property.ByNameRef[element.Element] + passwordPolicySettings *property.Part[element.Element] + fileDocumentAccess *property.Part[element.Element] + imageAccess *property.Part[element.Element] + strictMode *property.Primitive[bool] +} + +// SecurityLevel returns the value of the securityLevel property. +func (o *ProjectSecurity) SecurityLevel() string { + return o.securityLevel.Get() +} + +// SetSecurityLevel sets the value of the securityLevel property. +func (o *ProjectSecurity) SetSecurityLevel(v string) { + o.securityLevel.Set(v) +} + +// CheckSecurity returns the value of the checkSecurity property. +func (o *ProjectSecurity) CheckSecurity() bool { + return o.checkSecurity.Get() +} + +// SetCheckSecurity sets the value of the checkSecurity property. +func (o *ProjectSecurity) SetCheckSecurity(v bool) { + o.checkSecurity.Set(v) +} + +// StrictPageUrlCheck returns the value of the strictPageUrlCheck property. +func (o *ProjectSecurity) StrictPageUrlCheck() bool { + return o.strictPageUrlCheck.Get() +} + +// SetStrictPageUrlCheck sets the value of the strictPageUrlCheck property. +func (o *ProjectSecurity) SetStrictPageUrlCheck(v bool) { + o.strictPageUrlCheck.Set(v) +} + +// UserRolesItems returns the value of the userRoles property. +func (o *ProjectSecurity) UserRolesItems() []element.Element { + return o.userRoles.Items() +} + +// AddUserRoles appends a child element to the userRoles list. +func (o *ProjectSecurity) AddUserRoles(v element.Element) { + o.userRoles.Append(v) +} + +// RemoveUserRoles removes the element at the given index from the userRoles list. +func (o *ProjectSecurity) RemoveUserRoles(index int) { + o.userRoles.Remove(index) +} + +// AdminUserName returns the value of the adminUserName property. +func (o *ProjectSecurity) AdminUserName() string { + return o.adminUserName.Get() +} + +// SetAdminUserName sets the value of the adminUserName property. +func (o *ProjectSecurity) SetAdminUserName(v string) { + o.adminUserName.Set(v) +} + +// AdminPassword returns the value of the adminPassword property. +func (o *ProjectSecurity) AdminPassword() string { + return o.adminPassword.Get() +} + +// SetAdminPassword sets the value of the adminPassword property. +func (o *ProjectSecurity) SetAdminPassword(v string) { + o.adminPassword.Set(v) +} + +// AdminUserRoleName returns the value of the adminUserRoleName property. +func (o *ProjectSecurity) AdminUserRoleName() string { + return o.adminUserRoleName.Get() +} + +// SetAdminUserRoleName sets the value of the adminUserRoleName property. +func (o *ProjectSecurity) SetAdminUserRoleName(v string) { + o.adminUserRoleName.Set(v) +} + +// EnableDemoUsers returns the value of the enableDemoUsers property. +func (o *ProjectSecurity) EnableDemoUsers() bool { + return o.enableDemoUsers.Get() +} + +// SetEnableDemoUsers sets the value of the enableDemoUsers property. +func (o *ProjectSecurity) SetEnableDemoUsers(v bool) { + o.enableDemoUsers.Set(v) +} + +// DemoUsersItems returns the value of the demoUsers property. +func (o *ProjectSecurity) DemoUsersItems() []element.Element { + return o.demoUsers.Items() +} + +// AddDemoUsers appends a child element to the demoUsers list. +func (o *ProjectSecurity) AddDemoUsers(v element.Element) { + o.demoUsers.Append(v) +} + +// RemoveDemoUsers removes the element at the given index from the demoUsers list. +func (o *ProjectSecurity) RemoveDemoUsers(index int) { + o.demoUsers.Remove(index) +} + +// EnableGuestAccess returns the value of the enableGuestAccess property. +func (o *ProjectSecurity) EnableGuestAccess() bool { + return o.enableGuestAccess.Get() +} + +// SetEnableGuestAccess sets the value of the enableGuestAccess property. +func (o *ProjectSecurity) SetEnableGuestAccess(v bool) { + o.enableGuestAccess.Set(v) +} + +// GuestUserRoleName returns the value of the guestUserRoleName property. +func (o *ProjectSecurity) GuestUserRoleName() string { + return o.guestUserRoleName.Get() +} + +// SetGuestUserRoleName sets the value of the guestUserRoleName property. +func (o *ProjectSecurity) SetGuestUserRoleName(v string) { + o.guestUserRoleName.Set(v) +} + +// SignInMicroflowQualifiedName returns the value of the signInMicroflow property. +func (o *ProjectSecurity) SignInMicroflowQualifiedName() string { + return o.signInMicroflow.QualifiedName() +} + +// SetSignInMicroflowQualifiedName sets the value of the signInMicroflow property. +func (o *ProjectSecurity) SetSignInMicroflowQualifiedName(v string) { + o.signInMicroflow.SetQualifiedName(v) +} + +// PasswordPolicySettings returns the value of the passwordPolicySettings property. +func (o *ProjectSecurity) PasswordPolicySettings() element.Element { + return o.passwordPolicySettings.Get() +} + +// SetPasswordPolicySettings sets the value of the passwordPolicySettings property. +func (o *ProjectSecurity) SetPasswordPolicySettings(v element.Element) { + o.passwordPolicySettings.Set(v) +} + +// FileDocumentAccess returns the value of the fileDocumentAccess property. +func (o *ProjectSecurity) FileDocumentAccess() element.Element { + return o.fileDocumentAccess.Get() +} + +// SetFileDocumentAccess sets the value of the fileDocumentAccess property. +func (o *ProjectSecurity) SetFileDocumentAccess(v element.Element) { + o.fileDocumentAccess.Set(v) +} + +// ImageAccess returns the value of the imageAccess property. +func (o *ProjectSecurity) ImageAccess() element.Element { + return o.imageAccess.Get() +} + +// SetImageAccess sets the value of the imageAccess property. +func (o *ProjectSecurity) SetImageAccess(v element.Element) { + o.imageAccess.Set(v) +} + +// StrictMode returns the value of the strictMode property. +func (o *ProjectSecurity) StrictMode() bool { + return o.strictMode.Get() +} + +// SetStrictMode sets the value of the strictMode property. +func (o *ProjectSecurity) SetStrictMode(v bool) { + o.strictMode.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ProjectSecurity) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("SecurityLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.securityLevel.SetFromDecode(s) + } + } + o.checkSecurity.Init(raw) + o.strictPageUrlCheck.Init(raw) + if children, err := codec.DecodeChildren(raw, "UserRoles"); err == nil { + for _, child := range children { + o.userRoles.AppendFromDecode(child) + } + } + o.adminUserName.Init(raw) + o.adminPassword.Init(raw) + o.adminUserRoleName.Init(raw) + o.enableDemoUsers.Init(raw) + if children, err := codec.DecodeChildren(raw, "DemoUsers"); err == nil { + for _, child := range children { + o.demoUsers.AppendFromDecode(child) + } + } + o.enableGuestAccess.Init(raw) + o.guestUserRoleName.Init(raw) + if val, err := raw.LookupErr("SignInMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.signInMicroflow.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "PasswordPolicySettings"); err == nil { + o.passwordPolicySettings.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "FileDocumentAccess"); err == nil { + o.fileDocumentAccess.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ImageAccess"); err == nil { + o.imageAccess.SetFromDecode(child) + } + o.strictMode.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// UserRole +// ──────────────────────────────────────────────────────── + +type UserRole struct { + element.Base + guid *property.Primitive[string] + name *property.Primitive[string] + description *property.Primitive[string] + moduleRoles *property.ByNameRefList[element.Element] + manageAllRoles *property.Primitive[bool] + manageableRoles *property.ByNameRefList[element.Element] + manageUsersWithoutRoles *property.Primitive[bool] + checkSecurity *property.Primitive[bool] +} + +// Guid returns the value of the guid property. +func (o *UserRole) Guid() string { + return o.guid.Get() +} + +// SetGuid sets the value of the guid property. +func (o *UserRole) SetGuid(v string) { + o.guid.Set(v) +} + +// Name returns the value of the name property. +func (o *UserRole) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *UserRole) SetName(v string) { + o.name.Set(v) +} + +// Description returns the value of the description property. +func (o *UserRole) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *UserRole) SetDescription(v string) { + o.description.Set(v) +} + +// ModuleRolesQualifiedNames returns the value of the moduleRoles property. +func (o *UserRole) ModuleRolesQualifiedNames() []string { + return o.moduleRoles.QualifiedNames() +} + +// SetModuleRolesQualifiedNames sets the value of the moduleRoles property. +func (o *UserRole) SetModuleRolesQualifiedNames(v []string) { + o.moduleRoles.SetQualifiedNames(v) +} + +// AddModuleRoles appends a child element to the moduleRoles list. +func (o *UserRole) AddModuleRoles(v string) { + o.moduleRoles.Append(v) +} + +// ManageAllRoles returns the value of the manageAllRoles property. +func (o *UserRole) ManageAllRoles() bool { + return o.manageAllRoles.Get() +} + +// SetManageAllRoles sets the value of the manageAllRoles property. +func (o *UserRole) SetManageAllRoles(v bool) { + o.manageAllRoles.Set(v) +} + +// ManageableRolesQualifiedNames returns the value of the manageableRoles property. +func (o *UserRole) ManageableRolesQualifiedNames() []string { + return o.manageableRoles.QualifiedNames() +} + +// SetManageableRolesQualifiedNames sets the value of the manageableRoles property. +func (o *UserRole) SetManageableRolesQualifiedNames(v []string) { + o.manageableRoles.SetQualifiedNames(v) +} + +// AddManageableRoles appends a child element to the manageableRoles list. +func (o *UserRole) AddManageableRoles(v string) { + o.manageableRoles.Append(v) +} + +// ManageUsersWithoutRoles returns the value of the manageUsersWithoutRoles property. +func (o *UserRole) ManageUsersWithoutRoles() bool { + return o.manageUsersWithoutRoles.Get() +} + +// SetManageUsersWithoutRoles sets the value of the manageUsersWithoutRoles property. +func (o *UserRole) SetManageUsersWithoutRoles(v bool) { + o.manageUsersWithoutRoles.Set(v) +} + +// CheckSecurity returns the value of the checkSecurity property. +func (o *UserRole) CheckSecurity() bool { + return o.checkSecurity.Get() +} + +// SetCheckSecurity sets the value of the checkSecurity property. +func (o *UserRole) SetCheckSecurity(v bool) { + o.checkSecurity.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserRole) InitFromRaw(raw bson.Raw) { + o.guid.Init(raw) + o.name.Init(raw) + o.description.Init(raw) + if val, err := raw.LookupErr("ModuleRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { + qnames = append(qnames, s) + } + } + o.moduleRoles.SetFromDecode(qnames) + } + } + o.manageAllRoles.Init(raw) + if val, err := raw.LookupErr("ManageableRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { + qnames = append(qnames, s) + } + } + o.manageableRoles.SetFromDecode(qnames) + } + } + o.manageUsersWithoutRoles.Init(raw) + o.checkSecurity.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initDemoUser creates a DemoUser with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDemoUser() *DemoUser { + o := &DemoUser{} + o.SetTypeName("Security$DemoUserImpl") + o.userName = property.NewPrimitive[string]("UserName", property.DecodeString) + o.userName.Bind(&o.Base, 0) + o.password = property.NewPrimitive[string]("Password", property.DecodeString) + o.password.Bind(&o.Base, 1) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 2) + o.userRoles = property.NewByNameRefList[element.Element]("UserRoles", "Security$UserRole") + o.userRoles.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.userName, o.password, o.entity, o.userRoles}) + return o +} + +// NewDemoUser creates a new DemoUser for user code. Marked dirty (bit 63 = new element). +func NewDemoUser() *DemoUser { + o := initDemoUser() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFileDocumentAccessRuleContainer creates a FileDocumentAccessRuleContainer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFileDocumentAccessRuleContainer() *FileDocumentAccessRuleContainer { + o := &FileDocumentAccessRuleContainer{} + o.SetTypeName("Security$FileDocumentAccessRuleContainer") + o.accessRules = property.NewPartList[element.Element]("AccessRules") + o.accessRules.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.accessRules}) + return o +} + +// NewFileDocumentAccessRuleContainer creates a new FileDocumentAccessRuleContainer for user code. Marked dirty (bit 63 = new element). +func NewFileDocumentAccessRuleContainer() *FileDocumentAccessRuleContainer { + o := initFileDocumentAccessRuleContainer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImageAccessRuleContainer creates a ImageAccessRuleContainer with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImageAccessRuleContainer() *ImageAccessRuleContainer { + o := &ImageAccessRuleContainer{} + o.SetTypeName("Security$ImageAccessRuleContainer") + o.accessRules = property.NewPartList[element.Element]("AccessRules") + o.accessRules.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.accessRules}) + return o +} + +// NewImageAccessRuleContainer creates a new ImageAccessRuleContainer for user code. Marked dirty (bit 63 = new element). +func NewImageAccessRuleContainer() *ImageAccessRuleContainer { + o := initImageAccessRuleContainer() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initModuleRole creates a ModuleRole with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initModuleRole() *ModuleRole { + o := &ModuleRole{} + o.SetTypeName("Security$ModuleRole") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.description}) + return o +} + +// NewModuleRole creates a new ModuleRole for user code. Marked dirty (bit 63 = new element). +func NewModuleRole() *ModuleRole { + o := initModuleRole() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initModuleSecurity creates a ModuleSecurity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initModuleSecurity() *ModuleSecurity { + o := &ModuleSecurity{} + o.SetTypeName("Security$ModuleSecurity") + o.moduleRoles = property.NewPartList[element.Element]("ModuleRoles") + o.moduleRoles.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.moduleRoles}) + return o +} + +// NewModuleSecurity creates a new ModuleSecurity for user code. Marked dirty (bit 63 = new element). +func NewModuleSecurity() *ModuleSecurity { + o := initModuleSecurity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPasswordPolicySettings creates a PasswordPolicySettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPasswordPolicySettings() *PasswordPolicySettings { + o := &PasswordPolicySettings{} + o.SetTypeName("Security$PasswordPolicySettings") + o.minimumLength = property.NewPrimitive[int32]("MinimumLength", property.DecodeInt32) + o.minimumLength.Bind(&o.Base, 0) + o.requireMixedCase = property.NewPrimitive[bool]("RequireMixedCase", property.DecodeBool) + o.requireMixedCase.Bind(&o.Base, 1) + o.requireSymbol = property.NewPrimitive[bool]("RequireSymbol", property.DecodeBool) + o.requireSymbol.Bind(&o.Base, 2) + o.requireDigit = property.NewPrimitive[bool]("RequireDigit", property.DecodeBool) + o.requireDigit.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.minimumLength, o.requireMixedCase, o.requireSymbol, o.requireDigit}) + return o +} + +// NewPasswordPolicySettings creates a new PasswordPolicySettings for user code. Marked dirty (bit 63 = new element). +func NewPasswordPolicySettings() *PasswordPolicySettings { + o := initPasswordPolicySettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initProjectSecurity creates a ProjectSecurity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initProjectSecurity() *ProjectSecurity { + o := &ProjectSecurity{} + o.SetTypeName("Security$ProjectSecurity") + o.securityLevel = property.NewEnum[string]("SecurityLevel") + o.securityLevel.Bind(&o.Base, 0) + o.checkSecurity = property.NewPrimitive[bool]("CheckSecurity", property.DecodeBool) + o.checkSecurity.Bind(&o.Base, 1) + o.strictPageUrlCheck = property.NewPrimitive[bool]("StrictPageUrlCheck", property.DecodeBool) + o.strictPageUrlCheck.Bind(&o.Base, 2) + o.userRoles = property.NewPartList[element.Element]("UserRoles") + o.userRoles.Bind(&o.Base, 3) + o.adminUserName = property.NewPrimitive[string]("AdminUserName", property.DecodeString) + o.adminUserName.Bind(&o.Base, 4) + o.adminPassword = property.NewPrimitive[string]("AdminPassword", property.DecodeString) + o.adminPassword.Bind(&o.Base, 5) + o.adminUserRoleName = property.NewPrimitive[string]("AdminUserRoleName", property.DecodeString) + o.adminUserRoleName.Bind(&o.Base, 6) + o.enableDemoUsers = property.NewPrimitive[bool]("EnableDemoUsers", property.DecodeBool) + o.enableDemoUsers.Bind(&o.Base, 7) + o.demoUsers = property.NewPartList[element.Element]("DemoUsers") + o.demoUsers.Bind(&o.Base, 8) + o.enableGuestAccess = property.NewPrimitive[bool]("EnableGuestAccess", property.DecodeBool) + o.enableGuestAccess.Bind(&o.Base, 9) + o.guestUserRoleName = property.NewPrimitive[string]("GuestUserRoleName", property.DecodeString) + o.guestUserRoleName.Bind(&o.Base, 10) + o.signInMicroflow = property.NewByNameRef[element.Element]("SignInMicroflow", "Microflows$Microflow") + o.signInMicroflow.Bind(&o.Base, 11) + o.passwordPolicySettings = property.NewPart[element.Element]("PasswordPolicySettings") + o.passwordPolicySettings.Bind(&o.Base, 12) + o.fileDocumentAccess = property.NewPart[element.Element]("FileDocumentAccess") + o.fileDocumentAccess.Bind(&o.Base, 13) + o.imageAccess = property.NewPart[element.Element]("ImageAccess") + o.imageAccess.Bind(&o.Base, 14) + o.strictMode = property.NewPrimitive[bool]("StrictMode", property.DecodeBool) + o.strictMode.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.securityLevel, o.checkSecurity, o.strictPageUrlCheck, o.userRoles, o.adminUserName, o.adminPassword, o.adminUserRoleName, o.enableDemoUsers, o.demoUsers, o.enableGuestAccess, o.guestUserRoleName, o.signInMicroflow, o.passwordPolicySettings, o.fileDocumentAccess, o.imageAccess, o.strictMode}) + return o +} + +// NewProjectSecurity creates a new ProjectSecurity for user code. Marked dirty (bit 63 = new element). +func NewProjectSecurity() *ProjectSecurity { + o := initProjectSecurity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUserRole creates a UserRole with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUserRole() *UserRole { + o := &UserRole{} + o.SetTypeName("Security$UserRole") + o.guid = property.NewPrimitive[string]("Guid", property.DecodeString) + o.guid.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 2) + o.moduleRoles = property.NewByNameRefList[element.Element]("ModuleRoles", "Security$ModuleRole") + o.moduleRoles.Bind(&o.Base, 3) + o.manageAllRoles = property.NewPrimitive[bool]("ManageAllRoles", property.DecodeBool) + o.manageAllRoles.Bind(&o.Base, 4) + o.manageableRoles = property.NewByNameRefList[element.Element]("ManageableRoles", "Security$UserRole") + o.manageableRoles.Bind(&o.Base, 5) + o.manageUsersWithoutRoles = property.NewPrimitive[bool]("ManageUsersWithoutRoles", property.DecodeBool) + o.manageUsersWithoutRoles.Bind(&o.Base, 6) + o.checkSecurity = property.NewPrimitive[bool]("CheckSecurity", property.DecodeBool) + o.checkSecurity.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.guid, o.name, o.description, o.moduleRoles, o.manageAllRoles, o.manageableRoles, o.manageUsersWithoutRoles, o.checkSecurity}) + return o +} + +// NewUserRole creates a new UserRole for user code. Marked dirty (bit 63 = new element). +func NewUserRole() *UserRole { + o := initUserRole() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Security$DemoUser", func() element.Element { + o := initDemoUser() + o.SetTypeName("Security$DemoUser") + return o + }) + codec.DefaultRegistry.Register("Security$DemoUserImpl", func() element.Element { + return initDemoUser() + }) + codec.DefaultRegistry.Register("Security$FileDocumentAccessRuleContainer", func() element.Element { + return initFileDocumentAccessRuleContainer() + }) + codec.DefaultRegistry.Register("Security$ImageAccessRuleContainer", func() element.Element { + return initImageAccessRuleContainer() + }) + codec.DefaultRegistry.Register("Security$ModuleRole", func() element.Element { + return initModuleRole() + }) + codec.DefaultRegistry.Register("Security$ModuleSecurity", func() element.Element { + return initModuleSecurity() + }) + codec.DefaultRegistry.Register("Security$PasswordPolicySettings", func() element.Element { + return initPasswordPolicySettings() + }) + codec.DefaultRegistry.Register("Security$ProjectSecurity", func() element.Element { + return initProjectSecurity() + }) + codec.DefaultRegistry.Register("Security$UserRole", func() element.Element { + return initUserRole() + }) +} diff --git a/modelsdk/gen/security/version.go b/modelsdk/gen/security/version.go new file mode 100644 index 00000000..bed5b00c --- /dev/null +++ b/modelsdk/gen/security/version.go @@ -0,0 +1,42 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package security + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Security$ModuleRole": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + }, + }, + "Security$ModuleSecurity": { + Properties: map[string]version.PropertyVersionInfo{ + "moduleRoles": {Public: true}, + }, + }, + "Security$PasswordPolicySettings": { + Properties: map[string]version.PropertyVersionInfo{ + "minimumLength": {}, + }, + }, + "Security$ProjectSecurity": { + Properties: map[string]version.PropertyVersionInfo{ + "fileDocumentAccess": {Required: true}, + "imageAccess": {Required: true}, + "passwordPolicySettings": {Required: true}, + "signInMicroflow": {Deleted: "8.0.0"}, + "strictMode": {Introduced: "9.24.0"}, + "strictPageUrlCheck": {Introduced: "9.8.0"}, + "userRoles": {Public: true}, + }, + }, + "Security$UserRole": { + Properties: map[string]version.PropertyVersionInfo{ + "name": {Public: true}, + }, + }, +} diff --git a/modelsdk/gen/services/enums.go b/modelsdk/gen/services/enums.go new file mode 100644 index 00000000..3085f1d0 --- /dev/null +++ b/modelsdk/gen/services/enums.go @@ -0,0 +1,18 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package services + +// HttpMethod enumerates the possible values for the HttpMethod type. +type HttpMethod = string + +const ( + HttpMethodGet HttpMethod = "Get" + HttpMethodPost HttpMethod = "Post" + HttpMethodPut HttpMethod = "Put" + HttpMethodPatch HttpMethod = "Patch" + HttpMethodDelete HttpMethod = "Delete" + HttpMethodHead HttpMethod = "Head" + HttpMethodOptions HttpMethod = "Options" +) diff --git a/modelsdk/gen/services/refs.go b/modelsdk/gen/services/refs.go new file mode 100644 index 00000000..b4bd94de --- /dev/null +++ b/modelsdk/gen/services/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package services diff --git a/modelsdk/gen/services/types.go b/modelsdk/gen/services/types.go new file mode 100644 index 00000000..9d7c563d --- /dev/null +++ b/modelsdk/gen/services/types.go @@ -0,0 +1,27 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package services + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +func init() { +} diff --git a/modelsdk/gen/services/version.go b/modelsdk/gen/services/version.go new file mode 100644 index 00000000..f7960b7c --- /dev/null +++ b/modelsdk/gen/services/version.go @@ -0,0 +1,10 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package services + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{} diff --git a/modelsdk/gen/settings/enums.go b/modelsdk/gen/settings/enums.go new file mode 100644 index 00000000..1c68d4b5 --- /dev/null +++ b/modelsdk/gen/settings/enums.go @@ -0,0 +1,95 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package settings + +// CertificateType enumerates the possible values for the CertificateType type. +type CertificateType = string + +const ( + CertificateTypeAuthority CertificateType = "Authority" + CertificateTypeClient CertificateType = "Client" +) + +// DatabaseType enumerates the possible values for the DatabaseType type. +type DatabaseType = string + +const ( + DatabaseTypeHsqldb DatabaseType = "Hsqldb" + DatabaseTypeDb2 DatabaseType = "Db2" + DatabaseTypeSqlServer DatabaseType = "SqlServer" + DatabaseTypeMySql DatabaseType = "MySql" + DatabaseTypeOracle DatabaseType = "Oracle" + DatabaseTypePostgreSql DatabaseType = "PostgreSql" + DatabaseTypeSapHana DatabaseType = "SapHana" +) + +// FirstDayOfWeekEnum enumerates the possible values for the FirstDayOfWeekEnum type. +type FirstDayOfWeekEnum = string + +const ( + FirstDayOfWeekEnumDefault FirstDayOfWeekEnum = "Default" + FirstDayOfWeekEnumSunday FirstDayOfWeekEnum = "Sunday" + FirstDayOfWeekEnumMonday FirstDayOfWeekEnum = "Monday" + FirstDayOfWeekEnumTuesday FirstDayOfWeekEnum = "Tuesday" + FirstDayOfWeekEnumWednesday FirstDayOfWeekEnum = "Wednesday" + FirstDayOfWeekEnumThursday FirstDayOfWeekEnum = "Thursday" + FirstDayOfWeekEnumFriday FirstDayOfWeekEnum = "Friday" + FirstDayOfWeekEnumSaturday FirstDayOfWeekEnum = "Saturday" +) + +// HashAlgorithmType enumerates the possible values for the HashAlgorithmType type. +type HashAlgorithmType = string + +const ( + HashAlgorithmTypeBCrypt HashAlgorithmType = "BCrypt" + HashAlgorithmTypeSSHA256 HashAlgorithmType = "SSHA256" + HashAlgorithmTypeSHA256 HashAlgorithmType = "SHA256" + HashAlgorithmTypeMD5 HashAlgorithmType = "MD5" +) + +// JavaVersion enumerates the possible values for the JavaVersion type. +type JavaVersion = string + +const ( + JavaVersionJava11 JavaVersion = "Java11" + JavaVersionJava17 JavaVersion = "Java17" + JavaVersionJava21 JavaVersion = "Java21" +) + +// RoundingMode enumerates the possible values for the RoundingMode type. +type RoundingMode = string + +const ( + RoundingModeHalfUp RoundingMode = "HalfUp" + RoundingModeHalfEven RoundingMode = "HalfEven" +) + +// SslCertificateAlgorithm enumerates the possible values for the SslCertificateAlgorithm type. +type SslCertificateAlgorithm = string + +const ( + SslCertificateAlgorithmPKIX SslCertificateAlgorithm = "PKIX" + SslCertificateAlgorithmSunX509 SslCertificateAlgorithm = "SunX509" +) + +// ThemeConversionStatusEnum enumerates the possible values for the ThemeConversionStatusEnum type. +type ThemeConversionStatusEnum = string + +const ( + ThemeConversionStatusEnumDone ThemeConversionStatusEnum = "Done" + ThemeConversionStatusEnumConvertedChangesInVariables ThemeConversionStatusEnum = "ConvertedChangesInVariables" + ThemeConversionStatusEnumConvertedChangesInCustom ThemeConversionStatusEnum = "ConvertedChangesInCustom" + ThemeConversionStatusEnumChangesInAtlas ThemeConversionStatusEnum = "ChangesInAtlas" + ThemeConversionStatusEnumAtlasNotFound ThemeConversionStatusEnum = "AtlasNotFound" +) + +// UseOptimizedClient enumerates the possible values for the UseOptimizedClient type. +type UseOptimizedClient = string + +const ( + UseOptimizedClientNo UseOptimizedClient = "No" + UseOptimizedClientYes UseOptimizedClient = "Yes" + UseOptimizedClientMigrationMode UseOptimizedClient = "MigrationMode" +) diff --git a/modelsdk/gen/settings/refs.go b/modelsdk/gen/settings/refs.go new file mode 100644 index 00000000..8600c12a --- /dev/null +++ b/modelsdk/gen/settings/refs.go @@ -0,0 +1,21 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package settings + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Settings$ConstantValue", []codec.RefMeta{ + {Prop: "Constant", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Settings$RuntimeSettings", []codec.RefMeta{ + {Prop: "AfterStartupMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "BeforeShutdownMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "HealthCheckMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Settings$WorkflowsProjectSettingsPart", []codec.RefMeta{ + {Prop: "UserEntity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) +} diff --git a/modelsdk/gen/settings/types.go b/modelsdk/gen/settings/types.go new file mode 100644 index 00000000..818c00f7 --- /dev/null +++ b/modelsdk/gen/settings/types.go @@ -0,0 +1,2496 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package settings + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// ActionActivityDefaultColor +// ──────────────────────────────────────────────────────── + +type ActionActivityDefaultColor struct { + element.Base + actionActivityType *property.Primitive[string] + backgroundColor *property.Enum[string] +} + +// ActionActivityType returns the value of the actionActivityType property. +func (o *ActionActivityDefaultColor) ActionActivityType() string { + return o.actionActivityType.Get() +} + +// SetActionActivityType sets the value of the actionActivityType property. +func (o *ActionActivityDefaultColor) SetActionActivityType(v string) { + o.actionActivityType.Set(v) +} + +// BackgroundColor returns the value of the backgroundColor property. +func (o *ActionActivityDefaultColor) BackgroundColor() string { + return o.backgroundColor.Get() +} + +// SetBackgroundColor sets the value of the backgroundColor property. +func (o *ActionActivityDefaultColor) SetBackgroundColor(v string) { + o.backgroundColor.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ActionActivityDefaultColor) InitFromRaw(raw bson.Raw) { + o.actionActivityType.Init(raw) + if val, err := raw.LookupErr("BackgroundColor"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.backgroundColor.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// Certificate +// ──────────────────────────────────────────────────────── + +type Certificate struct { + element.Base + propType *property.Enum[string] + data *property.Primitive[string] +} + +// Type returns the value of the type property. +func (o *Certificate) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *Certificate) SetType(v string) { + o.propType.Set(v) +} + +// Data returns the value of the data property. +func (o *Certificate) Data() string { + return o.data.Get() +} + +// SetData sets the value of the data property. +func (o *Certificate) SetData(v string) { + o.data.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Certificate) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Type"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.propType.SetFromDecode(s) + } + } + o.data.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ProjectSettingsPart +// ──────────────────────────────────────────────────────── + +type ProjectSettingsPart struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ProjectSettingsPart) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// CertificateSettings +// ──────────────────────────────────────────────────────── + +type CertificateSettings struct { + element.Base + certificates *property.PartList[element.Element] +} + +// CertificatesItems returns the value of the certificates property. +func (o *CertificateSettings) CertificatesItems() []element.Element { + return o.certificates.Items() +} + +// AddCertificates appends a child element to the certificates list. +func (o *CertificateSettings) AddCertificates(v element.Element) { + o.certificates.Append(v) +} + +// RemoveCertificates removes the element at the given index from the certificates list. +func (o *CertificateSettings) RemoveCertificates(index int) { + o.certificates.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CertificateSettings) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Certificates"); err == nil { + for _, child := range children { + o.certificates.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Configuration +// ──────────────────────────────────────────────────────── + +type Configuration struct { + element.Base + name *property.Primitive[string] + applicationRootUrl *property.Primitive[string] + runtimePortNumber *property.Primitive[int32] + adminPortNumber *property.Primitive[int32] + runtimePortOnlyLocal *property.Primitive[bool] + adminPortOnlyLocal *property.Primitive[bool] + maxJavaHeapSize *property.Primitive[int32] + emulateCloudSecurity *property.Primitive[bool] + extraJvmParameters *property.Primitive[string] + databaseType *property.Enum[string] + databaseUrl *property.Primitive[string] + databaseName *property.Primitive[string] + databaseUseIntegratedSecurity *property.Primitive[bool] + databaseUserName *property.Primitive[string] + databasePassword *property.Primitive[string] + customSettings *property.PartList[element.Element] + constantValues *property.PartList[element.Element] + tracing *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *Configuration) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Configuration) SetName(v string) { + o.name.Set(v) +} + +// ApplicationRootUrl returns the value of the applicationRootUrl property. +func (o *Configuration) ApplicationRootUrl() string { + return o.applicationRootUrl.Get() +} + +// SetApplicationRootUrl sets the value of the applicationRootUrl property. +func (o *Configuration) SetApplicationRootUrl(v string) { + o.applicationRootUrl.Set(v) +} + +// RuntimePortNumber returns the value of the runtimePortNumber property. +func (o *Configuration) RuntimePortNumber() int32 { + return o.runtimePortNumber.Get() +} + +// SetRuntimePortNumber sets the value of the runtimePortNumber property. +func (o *Configuration) SetRuntimePortNumber(v int32) { + o.runtimePortNumber.Set(v) +} + +// AdminPortNumber returns the value of the adminPortNumber property. +func (o *Configuration) AdminPortNumber() int32 { + return o.adminPortNumber.Get() +} + +// SetAdminPortNumber sets the value of the adminPortNumber property. +func (o *Configuration) SetAdminPortNumber(v int32) { + o.adminPortNumber.Set(v) +} + +// RuntimePortOnlyLocal returns the value of the runtimePortOnlyLocal property. +func (o *Configuration) RuntimePortOnlyLocal() bool { + return o.runtimePortOnlyLocal.Get() +} + +// SetRuntimePortOnlyLocal sets the value of the runtimePortOnlyLocal property. +func (o *Configuration) SetRuntimePortOnlyLocal(v bool) { + o.runtimePortOnlyLocal.Set(v) +} + +// AdminPortOnlyLocal returns the value of the adminPortOnlyLocal property. +func (o *Configuration) AdminPortOnlyLocal() bool { + return o.adminPortOnlyLocal.Get() +} + +// SetAdminPortOnlyLocal sets the value of the adminPortOnlyLocal property. +func (o *Configuration) SetAdminPortOnlyLocal(v bool) { + o.adminPortOnlyLocal.Set(v) +} + +// MaxJavaHeapSize returns the value of the maxJavaHeapSize property. +func (o *Configuration) MaxJavaHeapSize() int32 { + return o.maxJavaHeapSize.Get() +} + +// SetMaxJavaHeapSize sets the value of the maxJavaHeapSize property. +func (o *Configuration) SetMaxJavaHeapSize(v int32) { + o.maxJavaHeapSize.Set(v) +} + +// EmulateCloudSecurity returns the value of the emulateCloudSecurity property. +func (o *Configuration) EmulateCloudSecurity() bool { + return o.emulateCloudSecurity.Get() +} + +// SetEmulateCloudSecurity sets the value of the emulateCloudSecurity property. +func (o *Configuration) SetEmulateCloudSecurity(v bool) { + o.emulateCloudSecurity.Set(v) +} + +// ExtraJvmParameters returns the value of the extraJvmParameters property. +func (o *Configuration) ExtraJvmParameters() string { + return o.extraJvmParameters.Get() +} + +// SetExtraJvmParameters sets the value of the extraJvmParameters property. +func (o *Configuration) SetExtraJvmParameters(v string) { + o.extraJvmParameters.Set(v) +} + +// DatabaseType returns the value of the databaseType property. +func (o *Configuration) DatabaseType() string { + return o.databaseType.Get() +} + +// SetDatabaseType sets the value of the databaseType property. +func (o *Configuration) SetDatabaseType(v string) { + o.databaseType.Set(v) +} + +// DatabaseUrl returns the value of the databaseUrl property. +func (o *Configuration) DatabaseUrl() string { + return o.databaseUrl.Get() +} + +// SetDatabaseUrl sets the value of the databaseUrl property. +func (o *Configuration) SetDatabaseUrl(v string) { + o.databaseUrl.Set(v) +} + +// DatabaseName returns the value of the databaseName property. +func (o *Configuration) DatabaseName() string { + return o.databaseName.Get() +} + +// SetDatabaseName sets the value of the databaseName property. +func (o *Configuration) SetDatabaseName(v string) { + o.databaseName.Set(v) +} + +// DatabaseUseIntegratedSecurity returns the value of the databaseUseIntegratedSecurity property. +func (o *Configuration) DatabaseUseIntegratedSecurity() bool { + return o.databaseUseIntegratedSecurity.Get() +} + +// SetDatabaseUseIntegratedSecurity sets the value of the databaseUseIntegratedSecurity property. +func (o *Configuration) SetDatabaseUseIntegratedSecurity(v bool) { + o.databaseUseIntegratedSecurity.Set(v) +} + +// DatabaseUserName returns the value of the databaseUserName property. +func (o *Configuration) DatabaseUserName() string { + return o.databaseUserName.Get() +} + +// SetDatabaseUserName sets the value of the databaseUserName property. +func (o *Configuration) SetDatabaseUserName(v string) { + o.databaseUserName.Set(v) +} + +// DatabasePassword returns the value of the databasePassword property. +func (o *Configuration) DatabasePassword() string { + return o.databasePassword.Get() +} + +// SetDatabasePassword sets the value of the databasePassword property. +func (o *Configuration) SetDatabasePassword(v string) { + o.databasePassword.Set(v) +} + +// CustomSettingsItems returns the value of the customSettings property. +func (o *Configuration) CustomSettingsItems() []element.Element { + return o.customSettings.Items() +} + +// AddCustomSettings appends a child element to the customSettings list. +func (o *Configuration) AddCustomSettings(v element.Element) { + o.customSettings.Append(v) +} + +// RemoveCustomSettings removes the element at the given index from the customSettings list. +func (o *Configuration) RemoveCustomSettings(index int) { + o.customSettings.Remove(index) +} + +// ConstantValuesItems returns the value of the constantValues property. +func (o *Configuration) ConstantValuesItems() []element.Element { + return o.constantValues.Items() +} + +// AddConstantValues appends a child element to the constantValues list. +func (o *Configuration) AddConstantValues(v element.Element) { + o.constantValues.Append(v) +} + +// RemoveConstantValues removes the element at the given index from the constantValues list. +func (o *Configuration) RemoveConstantValues(index int) { + o.constantValues.Remove(index) +} + +// Tracing returns the value of the tracing property. +func (o *Configuration) Tracing() element.Element { + return o.tracing.Get() +} + +// SetTracing sets the value of the tracing property. +func (o *Configuration) SetTracing(v element.Element) { + o.tracing.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Configuration) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.applicationRootUrl.Init(raw) + o.runtimePortNumber.Init(raw) + o.adminPortNumber.Init(raw) + o.runtimePortOnlyLocal.Init(raw) + o.adminPortOnlyLocal.Init(raw) + o.maxJavaHeapSize.Init(raw) + o.emulateCloudSecurity.Init(raw) + o.extraJvmParameters.Init(raw) + if val, err := raw.LookupErr("DatabaseType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.databaseType.SetFromDecode(s) + } + } + o.databaseUrl.Init(raw) + o.databaseName.Init(raw) + o.databaseUseIntegratedSecurity.Init(raw) + o.databaseUserName.Init(raw) + o.databasePassword.Init(raw) + if children, err := codec.DecodeChildren(raw, "CustomSettings"); err == nil { + for _, child := range children { + o.customSettings.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "ConstantValues"); err == nil { + for _, child := range children { + o.constantValues.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Tracing"); err == nil { + o.tracing.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ConfigurationSettings +// ──────────────────────────────────────────────────────── + +type ConfigurationSettings struct { + element.Base + configurations *property.PartList[element.Element] +} + +// ConfigurationsItems returns the value of the configurations property. +func (o *ConfigurationSettings) ConfigurationsItems() []element.Element { + return o.configurations.Items() +} + +// AddConfigurations appends a child element to the configurations list. +func (o *ConfigurationSettings) AddConfigurations(v element.Element) { + o.configurations.Append(v) +} + +// RemoveConfigurations removes the element at the given index from the configurations list. +func (o *ConfigurationSettings) RemoveConfigurations(index int) { + o.configurations.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConfigurationSettings) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Configurations"); err == nil { + for _, child := range children { + o.configurations.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ConstantValue +// ──────────────────────────────────────────────────────── + +type ConstantValue struct { + element.Base + constant *property.ByNameRef[element.Element] + value *property.Primitive[string] + sharedOrPrivateValue *property.Part[element.Element] +} + +// ConstantQualifiedName returns the value of the constant property. +func (o *ConstantValue) ConstantQualifiedName() string { + return o.constant.QualifiedName() +} + +// SetConstantQualifiedName sets the value of the constant property. +func (o *ConstantValue) SetConstantQualifiedName(v string) { + o.constant.SetQualifiedName(v) +} + +// Value returns the value of the value property. +func (o *ConstantValue) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *ConstantValue) SetValue(v string) { + o.value.Set(v) +} + +// SharedOrPrivateValue returns the value of the sharedOrPrivateValue property. +func (o *ConstantValue) SharedOrPrivateValue() element.Element { + return o.sharedOrPrivateValue.Get() +} + +// SetSharedOrPrivateValue sets the value of the sharedOrPrivateValue property. +func (o *ConstantValue) SetSharedOrPrivateValue(v element.Element) { + o.sharedOrPrivateValue.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConstantValue) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Constant"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.constant.SetFromDecode(s) + } + } + o.value.Init(raw) + if child, err := codec.DecodeChild(raw, "SharedOrPrivateValue"); err == nil { + o.sharedOrPrivateValue.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// CustomSetting +// ──────────────────────────────────────────────────────── + +type CustomSetting struct { + element.Base + name *property.Primitive[string] + value *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *CustomSetting) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CustomSetting) SetName(v string) { + o.name.Set(v) +} + +// Value returns the value of the value property. +func (o *CustomSetting) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *CustomSetting) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CustomSetting) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DistributionSettings +// ──────────────────────────────────────────────────────── + +type DistributionSettings struct { + element.Base + isDistributable *property.Primitive[bool] + version *property.Primitive[string] + basedOnVersion *property.Primitive[string] +} + +// IsDistributable returns the value of the isDistributable property. +func (o *DistributionSettings) IsDistributable() bool { + return o.isDistributable.Get() +} + +// SetIsDistributable sets the value of the isDistributable property. +func (o *DistributionSettings) SetIsDistributable(v bool) { + o.isDistributable.Set(v) +} + +// Version returns the value of the version property. +func (o *DistributionSettings) Version() string { + return o.version.Get() +} + +// SetVersion sets the value of the version property. +func (o *DistributionSettings) SetVersion(v string) { + o.version.Set(v) +} + +// BasedOnVersion returns the value of the basedOnVersion property. +func (o *DistributionSettings) BasedOnVersion() string { + return o.basedOnVersion.Get() +} + +// SetBasedOnVersion sets the value of the basedOnVersion property. +func (o *DistributionSettings) SetBasedOnVersion(v string) { + o.basedOnVersion.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DistributionSettings) InitFromRaw(raw bson.Raw) { + o.isDistributable.Init(raw) + o.version.Init(raw) + o.basedOnVersion.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// IntegrationProjectSettingsPart +// ──────────────────────────────────────────────────────── + +type IntegrationProjectSettingsPart struct { + element.Base + obsoleteEnableUrlEncoding *property.Primitive[bool] +} + +// ObsoleteEnableUrlEncoding returns the value of the obsoleteEnableUrlEncoding property. +func (o *IntegrationProjectSettingsPart) ObsoleteEnableUrlEncoding() bool { + return o.obsoleteEnableUrlEncoding.Get() +} + +// SetObsoleteEnableUrlEncoding sets the value of the obsoleteEnableUrlEncoding property. +func (o *IntegrationProjectSettingsPart) SetObsoleteEnableUrlEncoding(v bool) { + o.obsoleteEnableUrlEncoding.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *IntegrationProjectSettingsPart) InitFromRaw(raw bson.Raw) { + o.obsoleteEnableUrlEncoding.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// JarDeploymentSettings +// ──────────────────────────────────────────────────────── + +type JarDeploymentSettings struct { + element.Base + exclusions *property.PartList[element.Element] +} + +// ExclusionsItems returns the value of the exclusions property. +func (o *JarDeploymentSettings) ExclusionsItems() []element.Element { + return o.exclusions.Items() +} + +// AddExclusions appends a child element to the exclusions list. +func (o *JarDeploymentSettings) AddExclusions(v element.Element) { + o.exclusions.Append(v) +} + +// RemoveExclusions removes the element at the given index from the exclusions list. +func (o *JarDeploymentSettings) RemoveExclusions(index int) { + o.exclusions.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JarDeploymentSettings) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Exclusions"); err == nil { + for _, child := range children { + o.exclusions.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// JarLocationBase +// ──────────────────────────────────────────────────────── + +type JarLocationBase struct { + element.Base + jarFileName *property.Primitive[string] +} + +// JarFileName returns the value of the jarFileName property. +func (o *JarLocationBase) JarFileName() string { + return o.jarFileName.Get() +} + +// SetJarFileName sets the value of the jarFileName property. +func (o *JarLocationBase) SetJarFileName(v string) { + o.jarFileName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JarLocationBase) InitFromRaw(raw bson.Raw) { + o.jarFileName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// JavaActionsSettings +// ──────────────────────────────────────────────────────── + +type JavaActionsSettings struct { + element.Base + generatePostfixesForParameters *property.Primitive[bool] +} + +// GeneratePostfixesForParameters returns the value of the generatePostfixesForParameters property. +func (o *JavaActionsSettings) GeneratePostfixesForParameters() bool { + return o.generatePostfixesForParameters.Get() +} + +// SetGeneratePostfixesForParameters sets the value of the generatePostfixesForParameters property. +func (o *JavaActionsSettings) SetGeneratePostfixesForParameters(v bool) { + o.generatePostfixesForParameters.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JavaActionsSettings) InitFromRaw(raw bson.Raw) { + o.generatePostfixesForParameters.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Language +// ──────────────────────────────────────────────────────── + +type Language struct { + element.Base + code *property.Primitive[string] + checkCompleteness *property.Primitive[bool] + customDateFormat *property.Primitive[string] + customTimeFormat *property.Primitive[string] + customDateTimeFormat *property.Primitive[string] +} + +// Code returns the value of the code property. +func (o *Language) Code() string { + return o.code.Get() +} + +// SetCode sets the value of the code property. +func (o *Language) SetCode(v string) { + o.code.Set(v) +} + +// CheckCompleteness returns the value of the checkCompleteness property. +func (o *Language) CheckCompleteness() bool { + return o.checkCompleteness.Get() +} + +// SetCheckCompleteness sets the value of the checkCompleteness property. +func (o *Language) SetCheckCompleteness(v bool) { + o.checkCompleteness.Set(v) +} + +// CustomDateFormat returns the value of the customDateFormat property. +func (o *Language) CustomDateFormat() string { + return o.customDateFormat.Get() +} + +// SetCustomDateFormat sets the value of the customDateFormat property. +func (o *Language) SetCustomDateFormat(v string) { + o.customDateFormat.Set(v) +} + +// CustomTimeFormat returns the value of the customTimeFormat property. +func (o *Language) CustomTimeFormat() string { + return o.customTimeFormat.Get() +} + +// SetCustomTimeFormat sets the value of the customTimeFormat property. +func (o *Language) SetCustomTimeFormat(v string) { + o.customTimeFormat.Set(v) +} + +// CustomDateTimeFormat returns the value of the customDateTimeFormat property. +func (o *Language) CustomDateTimeFormat() string { + return o.customDateTimeFormat.Get() +} + +// SetCustomDateTimeFormat sets the value of the customDateTimeFormat property. +func (o *Language) SetCustomDateTimeFormat(v string) { + o.customDateTimeFormat.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Language) InitFromRaw(raw bson.Raw) { + o.code.Init(raw) + o.checkCompleteness.Init(raw) + o.customDateFormat.Init(raw) + o.customTimeFormat.Init(raw) + o.customDateTimeFormat.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// LanguageSettings +// ──────────────────────────────────────────────────────── + +type LanguageSettings struct { + element.Base + defaultLanguageCode *property.Primitive[string] + languages *property.PartList[element.Element] +} + +// DefaultLanguageCode returns the value of the defaultLanguageCode property. +func (o *LanguageSettings) DefaultLanguageCode() string { + return o.defaultLanguageCode.Get() +} + +// SetDefaultLanguageCode sets the value of the defaultLanguageCode property. +func (o *LanguageSettings) SetDefaultLanguageCode(v string) { + o.defaultLanguageCode.Set(v) +} + +// LanguagesItems returns the value of the languages property. +func (o *LanguageSettings) LanguagesItems() []element.Element { + return o.languages.Items() +} + +// AddLanguages appends a child element to the languages list. +func (o *LanguageSettings) AddLanguages(v element.Element) { + o.languages.Append(v) +} + +// RemoveLanguages removes the element at the given index from the languages list. +func (o *LanguageSettings) RemoveLanguages(index int) { + o.languages.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LanguageSettings) InitFromRaw(raw bson.Raw) { + o.defaultLanguageCode.Init(raw) + if children, err := codec.DecodeChildren(raw, "Languages"); err == nil { + for _, child := range children { + o.languages.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ModelerSettings +// ──────────────────────────────────────────────────────── + +type ModelerSettings struct { + element.Base + lowerCaseMicroflowVariables *property.Primitive[bool] + actionActivityDefaultColors *property.PartList[element.Element] + defaultSequenceFlowLineType *property.Enum[string] + defaultAssociationStorage *property.Enum[string] +} + +// LowerCaseMicroflowVariables returns the value of the lowerCaseMicroflowVariables property. +func (o *ModelerSettings) LowerCaseMicroflowVariables() bool { + return o.lowerCaseMicroflowVariables.Get() +} + +// SetLowerCaseMicroflowVariables sets the value of the lowerCaseMicroflowVariables property. +func (o *ModelerSettings) SetLowerCaseMicroflowVariables(v bool) { + o.lowerCaseMicroflowVariables.Set(v) +} + +// ActionActivityDefaultColorsItems returns the value of the actionActivityDefaultColors property. +func (o *ModelerSettings) ActionActivityDefaultColorsItems() []element.Element { + return o.actionActivityDefaultColors.Items() +} + +// AddActionActivityDefaultColors appends a child element to the actionActivityDefaultColors list. +func (o *ModelerSettings) AddActionActivityDefaultColors(v element.Element) { + o.actionActivityDefaultColors.Append(v) +} + +// RemoveActionActivityDefaultColors removes the element at the given index from the actionActivityDefaultColors list. +func (o *ModelerSettings) RemoveActionActivityDefaultColors(index int) { + o.actionActivityDefaultColors.Remove(index) +} + +// DefaultSequenceFlowLineType returns the value of the defaultSequenceFlowLineType property. +func (o *ModelerSettings) DefaultSequenceFlowLineType() string { + return o.defaultSequenceFlowLineType.Get() +} + +// SetDefaultSequenceFlowLineType sets the value of the defaultSequenceFlowLineType property. +func (o *ModelerSettings) SetDefaultSequenceFlowLineType(v string) { + o.defaultSequenceFlowLineType.Set(v) +} + +// DefaultAssociationStorage returns the value of the defaultAssociationStorage property. +func (o *ModelerSettings) DefaultAssociationStorage() string { + return o.defaultAssociationStorage.Get() +} + +// SetDefaultAssociationStorage sets the value of the defaultAssociationStorage property. +func (o *ModelerSettings) SetDefaultAssociationStorage(v string) { + o.defaultAssociationStorage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ModelerSettings) InitFromRaw(raw bson.Raw) { + o.lowerCaseMicroflowVariables.Init(raw) + if children, err := codec.DecodeChildren(raw, "ActionActivityDefaultColors"); err == nil { + for _, child := range children { + o.actionActivityDefaultColors.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("DefaultSequenceFlowLineType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.defaultSequenceFlowLineType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("DefaultAssociationStorage"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.defaultAssociationStorage.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// SharedOrPrivateValue +// ──────────────────────────────────────────────────────── + +type SharedOrPrivateValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SharedOrPrivateValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// PrivateValue +// ──────────────────────────────────────────────────────── + +type PrivateValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PrivateValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ProjectSettings +// ──────────────────────────────────────────────────────── + +type ProjectSettings struct { + element.Base + settingsParts *property.PartList[element.Element] +} + +// SettingsPartsItems returns the value of the settingsParts property. +func (o *ProjectSettings) SettingsPartsItems() []element.Element { + return o.settingsParts.Items() +} + +// AddSettingsParts appends a child element to the settingsParts list. +func (o *ProjectSettings) AddSettingsParts(v element.Element) { + o.settingsParts.Append(v) +} + +// RemoveSettingsParts removes the element at the given index from the settingsParts list. +func (o *ProjectSettings) RemoveSettingsParts(index int) { + o.settingsParts.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ProjectSettings) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "SettingsParts"); err == nil { + for _, child := range children { + o.settingsParts.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ProtectedModuleJarLocation +// ──────────────────────────────────────────────────────── + +type ProtectedModuleJarLocation struct { + element.Base + jarFileName *property.Primitive[string] + moduleName *property.Primitive[string] +} + +// JarFileName returns the value of the jarFileName property. +func (o *ProtectedModuleJarLocation) JarFileName() string { + return o.jarFileName.Get() +} + +// SetJarFileName sets the value of the jarFileName property. +func (o *ProtectedModuleJarLocation) SetJarFileName(v string) { + o.jarFileName.Set(v) +} + +// ModuleName returns the value of the moduleName property. +func (o *ProtectedModuleJarLocation) ModuleName() string { + return o.moduleName.Get() +} + +// SetModuleName sets the value of the moduleName property. +func (o *ProtectedModuleJarLocation) SetModuleName(v string) { + o.moduleName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ProtectedModuleJarLocation) InitFromRaw(raw bson.Raw) { + o.jarFileName.Init(raw) + o.moduleName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RuntimeSettings +// ──────────────────────────────────────────────────────── + +type RuntimeSettings struct { + element.Base + afterStartupMicroflow *property.ByNameRef[element.Element] + beforeShutdownMicroflow *property.ByNameRef[element.Element] + healthCheckMicroflow *property.ByNameRef[element.Element] + firstDayOfWeek *property.Enum[string] + defaultTimeZoneCode *property.Primitive[string] + scheduledEventTimeZoneCode *property.Primitive[string] + hashAlgorithm *property.Enum[string] + bcryptCost *property.Primitive[int32] + roundingMode *property.Enum[string] + allowUserMultipleSessions *property.Primitive[bool] + enforceDataStorageUniqueness *property.Primitive[bool] + enableDataStorageOptimisticLocking *property.Primitive[bool] + enableDataStorageNewQueryHandling *property.Primitive[bool] + useDeprecatedClientForWebServiceCalls *property.Primitive[bool] + useSystemContextForBackgroundTasks *property.Primitive[bool] + useDatabaseForeignKeyConstraints *property.Primitive[bool] + javaVersion *property.Enum[string] + useOQLVersion2 *property.Primitive[bool] + sslCertificateAlgorithm *property.Enum[string] + decimalScale *property.Primitive[int32] +} + +// AfterStartupMicroflowQualifiedName returns the value of the afterStartupMicroflow property. +func (o *RuntimeSettings) AfterStartupMicroflowQualifiedName() string { + return o.afterStartupMicroflow.QualifiedName() +} + +// SetAfterStartupMicroflowQualifiedName sets the value of the afterStartupMicroflow property. +func (o *RuntimeSettings) SetAfterStartupMicroflowQualifiedName(v string) { + o.afterStartupMicroflow.SetQualifiedName(v) +} + +// BeforeShutdownMicroflowQualifiedName returns the value of the beforeShutdownMicroflow property. +func (o *RuntimeSettings) BeforeShutdownMicroflowQualifiedName() string { + return o.beforeShutdownMicroflow.QualifiedName() +} + +// SetBeforeShutdownMicroflowQualifiedName sets the value of the beforeShutdownMicroflow property. +func (o *RuntimeSettings) SetBeforeShutdownMicroflowQualifiedName(v string) { + o.beforeShutdownMicroflow.SetQualifiedName(v) +} + +// HealthCheckMicroflowQualifiedName returns the value of the healthCheckMicroflow property. +func (o *RuntimeSettings) HealthCheckMicroflowQualifiedName() string { + return o.healthCheckMicroflow.QualifiedName() +} + +// SetHealthCheckMicroflowQualifiedName sets the value of the healthCheckMicroflow property. +func (o *RuntimeSettings) SetHealthCheckMicroflowQualifiedName(v string) { + o.healthCheckMicroflow.SetQualifiedName(v) +} + +// FirstDayOfWeek returns the value of the firstDayOfWeek property. +func (o *RuntimeSettings) FirstDayOfWeek() string { + return o.firstDayOfWeek.Get() +} + +// SetFirstDayOfWeek sets the value of the firstDayOfWeek property. +func (o *RuntimeSettings) SetFirstDayOfWeek(v string) { + o.firstDayOfWeek.Set(v) +} + +// DefaultTimeZoneCode returns the value of the defaultTimeZoneCode property. +func (o *RuntimeSettings) DefaultTimeZoneCode() string { + return o.defaultTimeZoneCode.Get() +} + +// SetDefaultTimeZoneCode sets the value of the defaultTimeZoneCode property. +func (o *RuntimeSettings) SetDefaultTimeZoneCode(v string) { + o.defaultTimeZoneCode.Set(v) +} + +// ScheduledEventTimeZoneCode returns the value of the scheduledEventTimeZoneCode property. +func (o *RuntimeSettings) ScheduledEventTimeZoneCode() string { + return o.scheduledEventTimeZoneCode.Get() +} + +// SetScheduledEventTimeZoneCode sets the value of the scheduledEventTimeZoneCode property. +func (o *RuntimeSettings) SetScheduledEventTimeZoneCode(v string) { + o.scheduledEventTimeZoneCode.Set(v) +} + +// HashAlgorithm returns the value of the hashAlgorithm property. +func (o *RuntimeSettings) HashAlgorithm() string { + return o.hashAlgorithm.Get() +} + +// SetHashAlgorithm sets the value of the hashAlgorithm property. +func (o *RuntimeSettings) SetHashAlgorithm(v string) { + o.hashAlgorithm.Set(v) +} + +// BcryptCost returns the value of the bcryptCost property. +func (o *RuntimeSettings) BcryptCost() int32 { + return o.bcryptCost.Get() +} + +// SetBcryptCost sets the value of the bcryptCost property. +func (o *RuntimeSettings) SetBcryptCost(v int32) { + o.bcryptCost.Set(v) +} + +// RoundingMode returns the value of the roundingMode property. +func (o *RuntimeSettings) RoundingMode() string { + return o.roundingMode.Get() +} + +// SetRoundingMode sets the value of the roundingMode property. +func (o *RuntimeSettings) SetRoundingMode(v string) { + o.roundingMode.Set(v) +} + +// AllowUserMultipleSessions returns the value of the allowUserMultipleSessions property. +func (o *RuntimeSettings) AllowUserMultipleSessions() bool { + return o.allowUserMultipleSessions.Get() +} + +// SetAllowUserMultipleSessions sets the value of the allowUserMultipleSessions property. +func (o *RuntimeSettings) SetAllowUserMultipleSessions(v bool) { + o.allowUserMultipleSessions.Set(v) +} + +// EnforceDataStorageUniqueness returns the value of the enforceDataStorageUniqueness property. +func (o *RuntimeSettings) EnforceDataStorageUniqueness() bool { + return o.enforceDataStorageUniqueness.Get() +} + +// SetEnforceDataStorageUniqueness sets the value of the enforceDataStorageUniqueness property. +func (o *RuntimeSettings) SetEnforceDataStorageUniqueness(v bool) { + o.enforceDataStorageUniqueness.Set(v) +} + +// EnableDataStorageOptimisticLocking returns the value of the enableDataStorageOptimisticLocking property. +func (o *RuntimeSettings) EnableDataStorageOptimisticLocking() bool { + return o.enableDataStorageOptimisticLocking.Get() +} + +// SetEnableDataStorageOptimisticLocking sets the value of the enableDataStorageOptimisticLocking property. +func (o *RuntimeSettings) SetEnableDataStorageOptimisticLocking(v bool) { + o.enableDataStorageOptimisticLocking.Set(v) +} + +// EnableDataStorageNewQueryHandling returns the value of the enableDataStorageNewQueryHandling property. +func (o *RuntimeSettings) EnableDataStorageNewQueryHandling() bool { + return o.enableDataStorageNewQueryHandling.Get() +} + +// SetEnableDataStorageNewQueryHandling sets the value of the enableDataStorageNewQueryHandling property. +func (o *RuntimeSettings) SetEnableDataStorageNewQueryHandling(v bool) { + o.enableDataStorageNewQueryHandling.Set(v) +} + +// UseDeprecatedClientForWebServiceCalls returns the value of the useDeprecatedClientForWebServiceCalls property. +func (o *RuntimeSettings) UseDeprecatedClientForWebServiceCalls() bool { + return o.useDeprecatedClientForWebServiceCalls.Get() +} + +// SetUseDeprecatedClientForWebServiceCalls sets the value of the useDeprecatedClientForWebServiceCalls property. +func (o *RuntimeSettings) SetUseDeprecatedClientForWebServiceCalls(v bool) { + o.useDeprecatedClientForWebServiceCalls.Set(v) +} + +// UseSystemContextForBackgroundTasks returns the value of the useSystemContextForBackgroundTasks property. +func (o *RuntimeSettings) UseSystemContextForBackgroundTasks() bool { + return o.useSystemContextForBackgroundTasks.Get() +} + +// SetUseSystemContextForBackgroundTasks sets the value of the useSystemContextForBackgroundTasks property. +func (o *RuntimeSettings) SetUseSystemContextForBackgroundTasks(v bool) { + o.useSystemContextForBackgroundTasks.Set(v) +} + +// UseDatabaseForeignKeyConstraints returns the value of the useDatabaseForeignKeyConstraints property. +func (o *RuntimeSettings) UseDatabaseForeignKeyConstraints() bool { + return o.useDatabaseForeignKeyConstraints.Get() +} + +// SetUseDatabaseForeignKeyConstraints sets the value of the useDatabaseForeignKeyConstraints property. +func (o *RuntimeSettings) SetUseDatabaseForeignKeyConstraints(v bool) { + o.useDatabaseForeignKeyConstraints.Set(v) +} + +// JavaVersion returns the value of the javaVersion property. +func (o *RuntimeSettings) JavaVersion() string { + return o.javaVersion.Get() +} + +// SetJavaVersion sets the value of the javaVersion property. +func (o *RuntimeSettings) SetJavaVersion(v string) { + o.javaVersion.Set(v) +} + +// UseOQLVersion2 returns the value of the useOQLVersion2 property. +func (o *RuntimeSettings) UseOQLVersion2() bool { + return o.useOQLVersion2.Get() +} + +// SetUseOQLVersion2 sets the value of the useOQLVersion2 property. +func (o *RuntimeSettings) SetUseOQLVersion2(v bool) { + o.useOQLVersion2.Set(v) +} + +// SslCertificateAlgorithm returns the value of the sslCertificateAlgorithm property. +func (o *RuntimeSettings) SslCertificateAlgorithm() string { + return o.sslCertificateAlgorithm.Get() +} + +// SetSslCertificateAlgorithm sets the value of the sslCertificateAlgorithm property. +func (o *RuntimeSettings) SetSslCertificateAlgorithm(v string) { + o.sslCertificateAlgorithm.Set(v) +} + +// DecimalScale returns the value of the decimalScale property. +func (o *RuntimeSettings) DecimalScale() int32 { + return o.decimalScale.Get() +} + +// SetDecimalScale sets the value of the decimalScale property. +func (o *RuntimeSettings) SetDecimalScale(v int32) { + o.decimalScale.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RuntimeSettings) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("AfterStartupMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.afterStartupMicroflow.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("BeforeShutdownMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.beforeShutdownMicroflow.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("HealthCheckMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.healthCheckMicroflow.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("FirstDayOfWeek"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.firstDayOfWeek.SetFromDecode(s) + } + } + o.defaultTimeZoneCode.Init(raw) + o.scheduledEventTimeZoneCode.Init(raw) + if val, err := raw.LookupErr("HashAlgorithm"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.hashAlgorithm.SetFromDecode(s) + } + } + o.bcryptCost.Init(raw) + if val, err := raw.LookupErr("RoundingMode"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.roundingMode.SetFromDecode(s) + } + } + o.allowUserMultipleSessions.Init(raw) + o.enforceDataStorageUniqueness.Init(raw) + o.enableDataStorageOptimisticLocking.Init(raw) + o.enableDataStorageNewQueryHandling.Init(raw) + o.useDeprecatedClientForWebServiceCalls.Init(raw) + o.useSystemContextForBackgroundTasks.Init(raw) + o.useDatabaseForeignKeyConstraints.Init(raw) + if val, err := raw.LookupErr("JavaVersion"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.javaVersion.SetFromDecode(s) + } + } + o.useOQLVersion2.Init(raw) + if val, err := raw.LookupErr("SslCertificateAlgorithm"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.sslCertificateAlgorithm.SetFromDecode(s) + } + } + o.decimalScale.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SharedValue +// ──────────────────────────────────────────────────────── + +type SharedValue struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *SharedValue) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *SharedValue) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SharedValue) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ThemeModuleEntry +// ──────────────────────────────────────────────────────── + +type ThemeModuleEntry struct { + element.Base + moduleName *property.Primitive[string] +} + +// ModuleName returns the value of the moduleName property. +func (o *ThemeModuleEntry) ModuleName() string { + return o.moduleName.Get() +} + +// SetModuleName sets the value of the moduleName property. +func (o *ThemeModuleEntry) SetModuleName(v string) { + o.moduleName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ThemeModuleEntry) InitFromRaw(raw bson.Raw) { + o.moduleName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// TracingConfiguration +// ──────────────────────────────────────────────────────── + +type TracingConfiguration struct { + element.Base + enabled *property.Primitive[bool] + serviceName *property.Primitive[string] + endpoint *property.Primitive[string] +} + +// Enabled returns the value of the enabled property. +func (o *TracingConfiguration) Enabled() bool { + return o.enabled.Get() +} + +// SetEnabled sets the value of the enabled property. +func (o *TracingConfiguration) SetEnabled(v bool) { + o.enabled.Set(v) +} + +// ServiceName returns the value of the serviceName property. +func (o *TracingConfiguration) ServiceName() string { + return o.serviceName.Get() +} + +// SetServiceName sets the value of the serviceName property. +func (o *TracingConfiguration) SetServiceName(v string) { + o.serviceName.Set(v) +} + +// Endpoint returns the value of the endpoint property. +func (o *TracingConfiguration) Endpoint() string { + return o.endpoint.Get() +} + +// SetEndpoint sets the value of the endpoint property. +func (o *TracingConfiguration) SetEndpoint(v string) { + o.endpoint.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TracingConfiguration) InitFromRaw(raw bson.Raw) { + o.enabled.Init(raw) + o.serviceName.Init(raw) + o.endpoint.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// UserLibJarLocation +// ──────────────────────────────────────────────────────── + +type UserLibJarLocation struct { + element.Base + jarFileName *property.Primitive[string] +} + +// JarFileName returns the value of the jarFileName property. +func (o *UserLibJarLocation) JarFileName() string { + return o.jarFileName.Get() +} + +// SetJarFileName sets the value of the jarFileName property. +func (o *UserLibJarLocation) SetJarFileName(v string) { + o.jarFileName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserLibJarLocation) InitFromRaw(raw bson.Raw) { + o.jarFileName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WebUIProjectSettingsPart +// ──────────────────────────────────────────────────────── + +type WebUIProjectSettingsPart struct { + element.Base + useOptimizedClient *property.Enum[string] + urlPrefix *property.Primitive[string] + theme *property.Primitive[string] + themeModuleName *property.Primitive[string] + feedbackWidgetUpdated *property.Primitive[bool] + enableWidgetBundling *property.Primitive[bool] + enableDownloadResources *property.Primitive[bool] + enableMicroflowReachabilityAnalysis *property.Primitive[bool] + themeConversionStatus *property.Enum[string] + themeModuleOrder *property.PartList[element.Element] + enableNewWidgetGeneration *property.Primitive[bool] + enableNewStringBehavior *property.Primitive[bool] + exportEmbeddedEntrypoint *property.Primitive[bool] + enableRspackBundler *property.Primitive[bool] +} + +// UseOptimizedClient returns the value of the useOptimizedClient property. +func (o *WebUIProjectSettingsPart) UseOptimizedClient() string { + return o.useOptimizedClient.Get() +} + +// SetUseOptimizedClient sets the value of the useOptimizedClient property. +func (o *WebUIProjectSettingsPart) SetUseOptimizedClient(v string) { + o.useOptimizedClient.Set(v) +} + +// UrlPrefix returns the value of the urlPrefix property. +func (o *WebUIProjectSettingsPart) UrlPrefix() string { + return o.urlPrefix.Get() +} + +// SetUrlPrefix sets the value of the urlPrefix property. +func (o *WebUIProjectSettingsPart) SetUrlPrefix(v string) { + o.urlPrefix.Set(v) +} + +// Theme returns the value of the theme property. +func (o *WebUIProjectSettingsPart) Theme() string { + return o.theme.Get() +} + +// SetTheme sets the value of the theme property. +func (o *WebUIProjectSettingsPart) SetTheme(v string) { + o.theme.Set(v) +} + +// ThemeModuleName returns the value of the themeModuleName property. +func (o *WebUIProjectSettingsPart) ThemeModuleName() string { + return o.themeModuleName.Get() +} + +// SetThemeModuleName sets the value of the themeModuleName property. +func (o *WebUIProjectSettingsPart) SetThemeModuleName(v string) { + o.themeModuleName.Set(v) +} + +// FeedbackWidgetUpdated returns the value of the feedbackWidgetUpdated property. +func (o *WebUIProjectSettingsPart) FeedbackWidgetUpdated() bool { + return o.feedbackWidgetUpdated.Get() +} + +// SetFeedbackWidgetUpdated sets the value of the feedbackWidgetUpdated property. +func (o *WebUIProjectSettingsPart) SetFeedbackWidgetUpdated(v bool) { + o.feedbackWidgetUpdated.Set(v) +} + +// EnableWidgetBundling returns the value of the enableWidgetBundling property. +func (o *WebUIProjectSettingsPart) EnableWidgetBundling() bool { + return o.enableWidgetBundling.Get() +} + +// SetEnableWidgetBundling sets the value of the enableWidgetBundling property. +func (o *WebUIProjectSettingsPart) SetEnableWidgetBundling(v bool) { + o.enableWidgetBundling.Set(v) +} + +// EnableDownloadResources returns the value of the enableDownloadResources property. +func (o *WebUIProjectSettingsPart) EnableDownloadResources() bool { + return o.enableDownloadResources.Get() +} + +// SetEnableDownloadResources sets the value of the enableDownloadResources property. +func (o *WebUIProjectSettingsPart) SetEnableDownloadResources(v bool) { + o.enableDownloadResources.Set(v) +} + +// EnableMicroflowReachabilityAnalysis returns the value of the enableMicroflowReachabilityAnalysis property. +func (o *WebUIProjectSettingsPart) EnableMicroflowReachabilityAnalysis() bool { + return o.enableMicroflowReachabilityAnalysis.Get() +} + +// SetEnableMicroflowReachabilityAnalysis sets the value of the enableMicroflowReachabilityAnalysis property. +func (o *WebUIProjectSettingsPart) SetEnableMicroflowReachabilityAnalysis(v bool) { + o.enableMicroflowReachabilityAnalysis.Set(v) +} + +// ThemeConversionStatus returns the value of the themeConversionStatus property. +func (o *WebUIProjectSettingsPart) ThemeConversionStatus() string { + return o.themeConversionStatus.Get() +} + +// SetThemeConversionStatus sets the value of the themeConversionStatus property. +func (o *WebUIProjectSettingsPart) SetThemeConversionStatus(v string) { + o.themeConversionStatus.Set(v) +} + +// ThemeModuleOrderItems returns the value of the themeModuleOrder property. +func (o *WebUIProjectSettingsPart) ThemeModuleOrderItems() []element.Element { + return o.themeModuleOrder.Items() +} + +// AddThemeModuleOrder appends a child element to the themeModuleOrder list. +func (o *WebUIProjectSettingsPart) AddThemeModuleOrder(v element.Element) { + o.themeModuleOrder.Append(v) +} + +// RemoveThemeModuleOrder removes the element at the given index from the themeModuleOrder list. +func (o *WebUIProjectSettingsPart) RemoveThemeModuleOrder(index int) { + o.themeModuleOrder.Remove(index) +} + +// EnableNewWidgetGeneration returns the value of the enableNewWidgetGeneration property. +func (o *WebUIProjectSettingsPart) EnableNewWidgetGeneration() bool { + return o.enableNewWidgetGeneration.Get() +} + +// SetEnableNewWidgetGeneration sets the value of the enableNewWidgetGeneration property. +func (o *WebUIProjectSettingsPart) SetEnableNewWidgetGeneration(v bool) { + o.enableNewWidgetGeneration.Set(v) +} + +// EnableNewStringBehavior returns the value of the enableNewStringBehavior property. +func (o *WebUIProjectSettingsPart) EnableNewStringBehavior() bool { + return o.enableNewStringBehavior.Get() +} + +// SetEnableNewStringBehavior sets the value of the enableNewStringBehavior property. +func (o *WebUIProjectSettingsPart) SetEnableNewStringBehavior(v bool) { + o.enableNewStringBehavior.Set(v) +} + +// ExportEmbeddedEntrypoint returns the value of the exportEmbeddedEntrypoint property. +func (o *WebUIProjectSettingsPart) ExportEmbeddedEntrypoint() bool { + return o.exportEmbeddedEntrypoint.Get() +} + +// SetExportEmbeddedEntrypoint sets the value of the exportEmbeddedEntrypoint property. +func (o *WebUIProjectSettingsPart) SetExportEmbeddedEntrypoint(v bool) { + o.exportEmbeddedEntrypoint.Set(v) +} + +// EnableRspackBundler returns the value of the enableRspackBundler property. +func (o *WebUIProjectSettingsPart) EnableRspackBundler() bool { + return o.enableRspackBundler.Get() +} + +// SetEnableRspackBundler sets the value of the enableRspackBundler property. +func (o *WebUIProjectSettingsPart) SetEnableRspackBundler(v bool) { + o.enableRspackBundler.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WebUIProjectSettingsPart) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("UseOptimizedClient"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.useOptimizedClient.SetFromDecode(s) + } + } + o.urlPrefix.Init(raw) + o.theme.Init(raw) + o.themeModuleName.Init(raw) + o.feedbackWidgetUpdated.Init(raw) + o.enableWidgetBundling.Init(raw) + o.enableDownloadResources.Init(raw) + o.enableMicroflowReachabilityAnalysis.Init(raw) + if val, err := raw.LookupErr("ThemeConversionStatus"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.themeConversionStatus.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "ThemeModuleOrder"); err == nil { + for _, child := range children { + o.themeModuleOrder.AppendFromDecode(child) + } + } + o.enableNewWidgetGeneration.Init(raw) + o.enableNewStringBehavior.Init(raw) + o.exportEmbeddedEntrypoint.Init(raw) + o.enableRspackBundler.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WorkflowGroup +// ──────────────────────────────────────────────────────── + +type WorkflowGroup struct { + element.Base + name *property.Primitive[string] + description *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *WorkflowGroup) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *WorkflowGroup) SetName(v string) { + o.name.Set(v) +} + +// Description returns the value of the description property. +func (o *WorkflowGroup) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *WorkflowGroup) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowGroup) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WorkflowsProjectSettingsPart +// ──────────────────────────────────────────────────────── + +type WorkflowsProjectSettingsPart struct { + element.Base + enabled *property.Primitive[bool] + userEntity *property.ByNameRef[element.Element] + groups *property.PartList[element.Element] + workflowEngineParallelism *property.Primitive[int32] + defaultTaskParallelism *property.Primitive[int32] + workflowOnStateChangeEvent *property.Part[element.Element] + usertaskOnStateChangeEvent *property.Part[element.Element] + onWorkflowEvent *property.PartList[element.Element] +} + +// Enabled returns the value of the enabled property. +func (o *WorkflowsProjectSettingsPart) Enabled() bool { + return o.enabled.Get() +} + +// SetEnabled sets the value of the enabled property. +func (o *WorkflowsProjectSettingsPart) SetEnabled(v bool) { + o.enabled.Set(v) +} + +// UserEntityQualifiedName returns the value of the userEntity property. +func (o *WorkflowsProjectSettingsPart) UserEntityQualifiedName() string { + return o.userEntity.QualifiedName() +} + +// SetUserEntityQualifiedName sets the value of the userEntity property. +func (o *WorkflowsProjectSettingsPart) SetUserEntityQualifiedName(v string) { + o.userEntity.SetQualifiedName(v) +} + +// GroupsItems returns the value of the groups property. +func (o *WorkflowsProjectSettingsPart) GroupsItems() []element.Element { + return o.groups.Items() +} + +// AddGroups appends a child element to the groups list. +func (o *WorkflowsProjectSettingsPart) AddGroups(v element.Element) { + o.groups.Append(v) +} + +// RemoveGroups removes the element at the given index from the groups list. +func (o *WorkflowsProjectSettingsPart) RemoveGroups(index int) { + o.groups.Remove(index) +} + +// WorkflowEngineParallelism returns the value of the workflowEngineParallelism property. +func (o *WorkflowsProjectSettingsPart) WorkflowEngineParallelism() int32 { + return o.workflowEngineParallelism.Get() +} + +// SetWorkflowEngineParallelism sets the value of the workflowEngineParallelism property. +func (o *WorkflowsProjectSettingsPart) SetWorkflowEngineParallelism(v int32) { + o.workflowEngineParallelism.Set(v) +} + +// DefaultTaskParallelism returns the value of the defaultTaskParallelism property. +func (o *WorkflowsProjectSettingsPart) DefaultTaskParallelism() int32 { + return o.defaultTaskParallelism.Get() +} + +// SetDefaultTaskParallelism sets the value of the defaultTaskParallelism property. +func (o *WorkflowsProjectSettingsPart) SetDefaultTaskParallelism(v int32) { + o.defaultTaskParallelism.Set(v) +} + +// WorkflowOnStateChangeEvent returns the value of the workflowOnStateChangeEvent property. +func (o *WorkflowsProjectSettingsPart) WorkflowOnStateChangeEvent() element.Element { + return o.workflowOnStateChangeEvent.Get() +} + +// SetWorkflowOnStateChangeEvent sets the value of the workflowOnStateChangeEvent property. +func (o *WorkflowsProjectSettingsPart) SetWorkflowOnStateChangeEvent(v element.Element) { + o.workflowOnStateChangeEvent.Set(v) +} + +// UsertaskOnStateChangeEvent returns the value of the usertaskOnStateChangeEvent property. +func (o *WorkflowsProjectSettingsPart) UsertaskOnStateChangeEvent() element.Element { + return o.usertaskOnStateChangeEvent.Get() +} + +// SetUsertaskOnStateChangeEvent sets the value of the usertaskOnStateChangeEvent property. +func (o *WorkflowsProjectSettingsPart) SetUsertaskOnStateChangeEvent(v element.Element) { + o.usertaskOnStateChangeEvent.Set(v) +} + +// OnWorkflowEventItems returns the value of the onWorkflowEvent property. +func (o *WorkflowsProjectSettingsPart) OnWorkflowEventItems() []element.Element { + return o.onWorkflowEvent.Items() +} + +// AddOnWorkflowEvent appends a child element to the onWorkflowEvent list. +func (o *WorkflowsProjectSettingsPart) AddOnWorkflowEvent(v element.Element) { + o.onWorkflowEvent.Append(v) +} + +// RemoveOnWorkflowEvent removes the element at the given index from the onWorkflowEvent list. +func (o *WorkflowsProjectSettingsPart) RemoveOnWorkflowEvent(index int) { + o.onWorkflowEvent.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowsProjectSettingsPart) InitFromRaw(raw bson.Raw) { + o.enabled.Init(raw) + if val, err := raw.LookupErr("UserEntity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.userEntity.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Groups"); err == nil { + for _, child := range children { + o.groups.AppendFromDecode(child) + } + } + o.workflowEngineParallelism.Init(raw) + o.defaultTaskParallelism.Init(raw) + if child, err := codec.DecodeChild(raw, "WorkflowOnStateChangeEvent"); err == nil { + o.workflowOnStateChangeEvent.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "UsertaskOnStateChangeEvent"); err == nil { + o.usertaskOnStateChangeEvent.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "OnWorkflowEvent"); err == nil { + for _, child := range children { + o.onWorkflowEvent.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initActionActivityDefaultColor creates a ActionActivityDefaultColor with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initActionActivityDefaultColor() *ActionActivityDefaultColor { + o := &ActionActivityDefaultColor{} + o.SetTypeName("Settings$ActionActivityDefaultColor") + o.actionActivityType = property.NewPrimitive[string]("ActionActivityType", property.DecodeString) + o.actionActivityType.Bind(&o.Base, 0) + o.backgroundColor = property.NewEnum[string]("BackgroundColor") + o.backgroundColor.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.actionActivityType, o.backgroundColor}) + return o +} + +// NewActionActivityDefaultColor creates a new ActionActivityDefaultColor for user code. Marked dirty (bit 63 = new element). +func NewActionActivityDefaultColor() *ActionActivityDefaultColor { + o := initActionActivityDefaultColor() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCertificate creates a Certificate with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCertificate() *Certificate { + o := &Certificate{} + o.SetTypeName("Settings$Certificate") + o.propType = property.NewEnum[string]("Type") + o.propType.Bind(&o.Base, 0) + o.data = property.NewPrimitive[string]("Data", property.DecodeString) + o.data.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.propType, o.data}) + return o +} + +// NewCertificate creates a new Certificate for user code. Marked dirty (bit 63 = new element). +func NewCertificate() *Certificate { + o := initCertificate() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCertificateSettings creates a CertificateSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCertificateSettings() *CertificateSettings { + o := &CertificateSettings{} + o.SetTypeName("Settings$CertificateSettings") + o.certificates = property.NewPartList[element.Element]("Certificates") + o.certificates.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.certificates}) + return o +} + +// NewCertificateSettings creates a new CertificateSettings for user code. Marked dirty (bit 63 = new element). +func NewCertificateSettings() *CertificateSettings { + o := initCertificateSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConfiguration creates a Configuration with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConfiguration() *Configuration { + o := &Configuration{} + o.SetTypeName("Settings$Configuration") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.applicationRootUrl = property.NewPrimitive[string]("ApplicationRootUrl", property.DecodeString) + o.applicationRootUrl.Bind(&o.Base, 1) + o.runtimePortNumber = property.NewPrimitive[int32]("RuntimePortNumber", property.DecodeInt32) + o.runtimePortNumber.Bind(&o.Base, 2) + o.adminPortNumber = property.NewPrimitive[int32]("AdminPortNumber", property.DecodeInt32) + o.adminPortNumber.Bind(&o.Base, 3) + o.runtimePortOnlyLocal = property.NewPrimitive[bool]("RuntimePortOnlyLocal", property.DecodeBool) + o.runtimePortOnlyLocal.Bind(&o.Base, 4) + o.adminPortOnlyLocal = property.NewPrimitive[bool]("AdminPortOnlyLocal", property.DecodeBool) + o.adminPortOnlyLocal.Bind(&o.Base, 5) + o.maxJavaHeapSize = property.NewPrimitive[int32]("MaxJavaHeapSize", property.DecodeInt32) + o.maxJavaHeapSize.Bind(&o.Base, 6) + o.emulateCloudSecurity = property.NewPrimitive[bool]("EmulateCloudSecurity", property.DecodeBool) + o.emulateCloudSecurity.Bind(&o.Base, 7) + o.extraJvmParameters = property.NewPrimitive[string]("ExtraJvmParameters", property.DecodeString) + o.extraJvmParameters.Bind(&o.Base, 8) + o.databaseType = property.NewEnum[string]("DatabaseType") + o.databaseType.Bind(&o.Base, 9) + o.databaseUrl = property.NewPrimitive[string]("DatabaseUrl", property.DecodeString) + o.databaseUrl.Bind(&o.Base, 10) + o.databaseName = property.NewPrimitive[string]("DatabaseName", property.DecodeString) + o.databaseName.Bind(&o.Base, 11) + o.databaseUseIntegratedSecurity = property.NewPrimitive[bool]("DatabaseUseIntegratedSecurity", property.DecodeBool) + o.databaseUseIntegratedSecurity.Bind(&o.Base, 12) + o.databaseUserName = property.NewPrimitive[string]("DatabaseUserName", property.DecodeString) + o.databaseUserName.Bind(&o.Base, 13) + o.databasePassword = property.NewPrimitive[string]("DatabasePassword", property.DecodeString) + o.databasePassword.Bind(&o.Base, 14) + o.customSettings = property.NewPartList[element.Element]("CustomSettings") + o.customSettings.Bind(&o.Base, 15) + o.constantValues = property.NewPartList[element.Element]("ConstantValues") + o.constantValues.Bind(&o.Base, 16) + o.tracing = property.NewPart[element.Element]("Tracing") + o.tracing.Bind(&o.Base, 17) + o.SetProperties([]element.Property{o.name, o.applicationRootUrl, o.runtimePortNumber, o.adminPortNumber, o.runtimePortOnlyLocal, o.adminPortOnlyLocal, o.maxJavaHeapSize, o.emulateCloudSecurity, o.extraJvmParameters, o.databaseType, o.databaseUrl, o.databaseName, o.databaseUseIntegratedSecurity, o.databaseUserName, o.databasePassword, o.customSettings, o.constantValues, o.tracing}) + return o +} + +// NewConfiguration creates a new Configuration for user code. Marked dirty (bit 63 = new element). +func NewConfiguration() *Configuration { + o := initConfiguration() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConfigurationSettings creates a ConfigurationSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConfigurationSettings() *ConfigurationSettings { + o := &ConfigurationSettings{} + o.SetTypeName("Settings$ConfigurationSettings") + o.configurations = property.NewPartList[element.Element]("Configurations") + o.configurations.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.configurations}) + return o +} + +// NewConfigurationSettings creates a new ConfigurationSettings for user code. Marked dirty (bit 63 = new element). +func NewConfigurationSettings() *ConfigurationSettings { + o := initConfigurationSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConstantValue creates a ConstantValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConstantValue() *ConstantValue { + o := &ConstantValue{} + o.SetTypeName("Settings$ConstantValue") + o.constant = property.NewByNameRef[element.Element]("Constant", "Constants$Constant") + o.constant.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.sharedOrPrivateValue = property.NewPart[element.Element]("SharedOrPrivateValue") + o.sharedOrPrivateValue.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.constant, o.value, o.sharedOrPrivateValue}) + return o +} + +// NewConstantValue creates a new ConstantValue for user code. Marked dirty (bit 63 = new element). +func NewConstantValue() *ConstantValue { + o := initConstantValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCustomSetting creates a CustomSetting with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCustomSetting() *CustomSetting { + o := &CustomSetting{} + o.SetTypeName("Settings$CustomSetting") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.value}) + return o +} + +// NewCustomSetting creates a new CustomSetting for user code. Marked dirty (bit 63 = new element). +func NewCustomSetting() *CustomSetting { + o := initCustomSetting() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDistributionSettings creates a DistributionSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDistributionSettings() *DistributionSettings { + o := &DistributionSettings{} + o.SetTypeName("Settings$DistributionSettings") + o.isDistributable = property.NewPrimitive[bool]("IsDistributable", property.DecodeBool) + o.isDistributable.Bind(&o.Base, 0) + o.version = property.NewPrimitive[string]("Version", property.DecodeString) + o.version.Bind(&o.Base, 1) + o.basedOnVersion = property.NewPrimitive[string]("BasedOnVersion", property.DecodeString) + o.basedOnVersion.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.isDistributable, o.version, o.basedOnVersion}) + return o +} + +// NewDistributionSettings creates a new DistributionSettings for user code. Marked dirty (bit 63 = new element). +func NewDistributionSettings() *DistributionSettings { + o := initDistributionSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initIntegrationProjectSettingsPart creates a IntegrationProjectSettingsPart with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initIntegrationProjectSettingsPart() *IntegrationProjectSettingsPart { + o := &IntegrationProjectSettingsPart{} + o.SetTypeName("Settings$IntegrationProjectSettingsPart") + o.obsoleteEnableUrlEncoding = property.NewPrimitive[bool]("ObsoleteEnableUrlEncoding", property.DecodeBool) + o.obsoleteEnableUrlEncoding.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.obsoleteEnableUrlEncoding}) + return o +} + +// NewIntegrationProjectSettingsPart creates a new IntegrationProjectSettingsPart for user code. Marked dirty (bit 63 = new element). +func NewIntegrationProjectSettingsPart() *IntegrationProjectSettingsPart { + o := initIntegrationProjectSettingsPart() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJarDeploymentSettings creates a JarDeploymentSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJarDeploymentSettings() *JarDeploymentSettings { + o := &JarDeploymentSettings{} + o.SetTypeName("Settings$JarDeploymentSettings") + o.exclusions = property.NewPartList[element.Element]("Exclusions") + o.exclusions.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.exclusions}) + return o +} + +// NewJarDeploymentSettings creates a new JarDeploymentSettings for user code. Marked dirty (bit 63 = new element). +func NewJarDeploymentSettings() *JarDeploymentSettings { + o := initJarDeploymentSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJavaActionsSettings creates a JavaActionsSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJavaActionsSettings() *JavaActionsSettings { + o := &JavaActionsSettings{} + o.SetTypeName("Settings$JavaActionsSettings") + o.generatePostfixesForParameters = property.NewPrimitive[bool]("GeneratePostfixesForParameters", property.DecodeBool) + o.generatePostfixesForParameters.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.generatePostfixesForParameters}) + return o +} + +// NewJavaActionsSettings creates a new JavaActionsSettings for user code. Marked dirty (bit 63 = new element). +func NewJavaActionsSettings() *JavaActionsSettings { + o := initJavaActionsSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLanguage creates a Language with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLanguage() *Language { + o := &Language{} + o.SetTypeName("Texts$Language") + o.code = property.NewPrimitive[string]("Code", property.DecodeString) + o.code.Bind(&o.Base, 0) + o.checkCompleteness = property.NewPrimitive[bool]("CheckCompleteness", property.DecodeBool) + o.checkCompleteness.Bind(&o.Base, 1) + o.customDateFormat = property.NewPrimitive[string]("CustomDateFormat", property.DecodeString) + o.customDateFormat.Bind(&o.Base, 2) + o.customTimeFormat = property.NewPrimitive[string]("CustomTimeFormat", property.DecodeString) + o.customTimeFormat.Bind(&o.Base, 3) + o.customDateTimeFormat = property.NewPrimitive[string]("CustomDateTimeFormat", property.DecodeString) + o.customDateTimeFormat.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.code, o.checkCompleteness, o.customDateFormat, o.customTimeFormat, o.customDateTimeFormat}) + return o +} + +// NewLanguage creates a new Language for user code. Marked dirty (bit 63 = new element). +func NewLanguage() *Language { + o := initLanguage() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLanguageSettings creates a LanguageSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLanguageSettings() *LanguageSettings { + o := &LanguageSettings{} + o.SetTypeName("Settings$LanguageSettings") + o.defaultLanguageCode = property.NewPrimitive[string]("DefaultLanguageCode", property.DecodeString) + o.defaultLanguageCode.Bind(&o.Base, 0) + o.languages = property.NewPartList[element.Element]("Languages") + o.languages.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.defaultLanguageCode, o.languages}) + return o +} + +// NewLanguageSettings creates a new LanguageSettings for user code. Marked dirty (bit 63 = new element). +func NewLanguageSettings() *LanguageSettings { + o := initLanguageSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initModelerSettings creates a ModelerSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initModelerSettings() *ModelerSettings { + o := &ModelerSettings{} + o.SetTypeName("Settings$ModelerSettings") + o.lowerCaseMicroflowVariables = property.NewPrimitive[bool]("LowerCaseMicroflowVariables", property.DecodeBool) + o.lowerCaseMicroflowVariables.Bind(&o.Base, 0) + o.actionActivityDefaultColors = property.NewPartList[element.Element]("ActionActivityDefaultColors") + o.actionActivityDefaultColors.Bind(&o.Base, 1) + o.defaultSequenceFlowLineType = property.NewEnum[string]("DefaultSequenceFlowLineType") + o.defaultSequenceFlowLineType.Bind(&o.Base, 2) + o.defaultAssociationStorage = property.NewEnum[string]("DefaultAssociationStorage") + o.defaultAssociationStorage.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.lowerCaseMicroflowVariables, o.actionActivityDefaultColors, o.defaultSequenceFlowLineType, o.defaultAssociationStorage}) + return o +} + +// NewModelerSettings creates a new ModelerSettings for user code. Marked dirty (bit 63 = new element). +func NewModelerSettings() *ModelerSettings { + o := initModelerSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPrivateValue creates a PrivateValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPrivateValue() *PrivateValue { + o := &PrivateValue{} + o.SetTypeName("Settings$PrivateValue") + o.SetProperties([]element.Property{}) + return o +} + +// NewPrivateValue creates a new PrivateValue for user code. Marked dirty (bit 63 = new element). +func NewPrivateValue() *PrivateValue { + o := initPrivateValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initProjectSettings creates a ProjectSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initProjectSettings() *ProjectSettings { + o := &ProjectSettings{} + o.SetTypeName("Settings$ProjectSettings") + o.settingsParts = property.NewPartList[element.Element]("SettingsParts") + o.settingsParts.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.settingsParts}) + return o +} + +// NewProjectSettings creates a new ProjectSettings for user code. Marked dirty (bit 63 = new element). +func NewProjectSettings() *ProjectSettings { + o := initProjectSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initProtectedModuleJarLocation creates a ProtectedModuleJarLocation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initProtectedModuleJarLocation() *ProtectedModuleJarLocation { + o := &ProtectedModuleJarLocation{} + o.SetTypeName("Settings$ProtectedModuleJarLocation") + o.jarFileName = property.NewPrimitive[string]("JarFileName", property.DecodeString) + o.jarFileName.Bind(&o.Base, 0) + o.moduleName = property.NewPrimitive[string]("ModuleName", property.DecodeString) + o.moduleName.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.jarFileName, o.moduleName}) + return o +} + +// NewProtectedModuleJarLocation creates a new ProtectedModuleJarLocation for user code. Marked dirty (bit 63 = new element). +func NewProtectedModuleJarLocation() *ProtectedModuleJarLocation { + o := initProtectedModuleJarLocation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRuntimeSettings creates a RuntimeSettings with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRuntimeSettings() *RuntimeSettings { + o := &RuntimeSettings{} + o.SetTypeName("Settings$RuntimeSettings") + o.afterStartupMicroflow = property.NewByNameRef[element.Element]("AfterStartupMicroflow", "Microflows$Microflow") + o.afterStartupMicroflow.Bind(&o.Base, 0) + o.beforeShutdownMicroflow = property.NewByNameRef[element.Element]("BeforeShutdownMicroflow", "Microflows$Microflow") + o.beforeShutdownMicroflow.Bind(&o.Base, 1) + o.healthCheckMicroflow = property.NewByNameRef[element.Element]("HealthCheckMicroflow", "Microflows$Microflow") + o.healthCheckMicroflow.Bind(&o.Base, 2) + o.firstDayOfWeek = property.NewEnum[string]("FirstDayOfWeek") + o.firstDayOfWeek.Bind(&o.Base, 3) + o.defaultTimeZoneCode = property.NewPrimitive[string]("DefaultTimeZoneCode", property.DecodeString) + o.defaultTimeZoneCode.Bind(&o.Base, 4) + o.scheduledEventTimeZoneCode = property.NewPrimitive[string]("ScheduledEventTimeZoneCode", property.DecodeString) + o.scheduledEventTimeZoneCode.Bind(&o.Base, 5) + o.hashAlgorithm = property.NewEnum[string]("HashAlgorithm") + o.hashAlgorithm.Bind(&o.Base, 6) + o.bcryptCost = property.NewPrimitive[int32]("BcryptCost", property.DecodeInt32) + o.bcryptCost.Bind(&o.Base, 7) + o.roundingMode = property.NewEnum[string]("RoundingMode") + o.roundingMode.Bind(&o.Base, 8) + o.allowUserMultipleSessions = property.NewPrimitive[bool]("AllowUserMultipleSessions", property.DecodeBool) + o.allowUserMultipleSessions.Bind(&o.Base, 9) + o.enforceDataStorageUniqueness = property.NewPrimitive[bool]("EnforceDataStorageUniqueness", property.DecodeBool) + o.enforceDataStorageUniqueness.Bind(&o.Base, 10) + o.enableDataStorageOptimisticLocking = property.NewPrimitive[bool]("EnableDataStorageOptimisticLocking", property.DecodeBool) + o.enableDataStorageOptimisticLocking.Bind(&o.Base, 11) + o.enableDataStorageNewQueryHandling = property.NewPrimitive[bool]("EnableDataStorageNewQueryHandling", property.DecodeBool) + o.enableDataStorageNewQueryHandling.Bind(&o.Base, 12) + o.useDeprecatedClientForWebServiceCalls = property.NewPrimitive[bool]("UseDeprecatedClientForWebServiceCalls", property.DecodeBool) + o.useDeprecatedClientForWebServiceCalls.Bind(&o.Base, 13) + o.useSystemContextForBackgroundTasks = property.NewPrimitive[bool]("UseSystemContextForBackgroundTasks", property.DecodeBool) + o.useSystemContextForBackgroundTasks.Bind(&o.Base, 14) + o.useDatabaseForeignKeyConstraints = property.NewPrimitive[bool]("UseDatabaseForeignKeyConstraints", property.DecodeBool) + o.useDatabaseForeignKeyConstraints.Bind(&o.Base, 15) + o.javaVersion = property.NewEnum[string]("JavaVersion") + o.javaVersion.Bind(&o.Base, 16) + o.useOQLVersion2 = property.NewPrimitive[bool]("UseOQLVersion2", property.DecodeBool) + o.useOQLVersion2.Bind(&o.Base, 17) + o.sslCertificateAlgorithm = property.NewEnum[string]("SslCertificateAlgorithm") + o.sslCertificateAlgorithm.Bind(&o.Base, 18) + o.decimalScale = property.NewPrimitive[int32]("DecimalScale", property.DecodeInt32) + o.decimalScale.Bind(&o.Base, 19) + o.SetProperties([]element.Property{o.afterStartupMicroflow, o.beforeShutdownMicroflow, o.healthCheckMicroflow, o.firstDayOfWeek, o.defaultTimeZoneCode, o.scheduledEventTimeZoneCode, o.hashAlgorithm, o.bcryptCost, o.roundingMode, o.allowUserMultipleSessions, o.enforceDataStorageUniqueness, o.enableDataStorageOptimisticLocking, o.enableDataStorageNewQueryHandling, o.useDeprecatedClientForWebServiceCalls, o.useSystemContextForBackgroundTasks, o.useDatabaseForeignKeyConstraints, o.javaVersion, o.useOQLVersion2, o.sslCertificateAlgorithm, o.decimalScale}) + return o +} + +// NewRuntimeSettings creates a new RuntimeSettings for user code. Marked dirty (bit 63 = new element). +func NewRuntimeSettings() *RuntimeSettings { + o := initRuntimeSettings() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSharedValue creates a SharedValue with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSharedValue() *SharedValue { + o := &SharedValue{} + o.SetTypeName("Settings$SharedValue") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value}) + return o +} + +// NewSharedValue creates a new SharedValue for user code. Marked dirty (bit 63 = new element). +func NewSharedValue() *SharedValue { + o := initSharedValue() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initThemeModuleEntry creates a ThemeModuleEntry with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initThemeModuleEntry() *ThemeModuleEntry { + o := &ThemeModuleEntry{} + o.SetTypeName("Settings$ThemeModuleEntry") + o.moduleName = property.NewPrimitive[string]("ModuleName", property.DecodeString) + o.moduleName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.moduleName}) + return o +} + +// NewThemeModuleEntry creates a new ThemeModuleEntry for user code. Marked dirty (bit 63 = new element). +func NewThemeModuleEntry() *ThemeModuleEntry { + o := initThemeModuleEntry() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTracingConfiguration creates a TracingConfiguration with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTracingConfiguration() *TracingConfiguration { + o := &TracingConfiguration{} + o.SetTypeName("Settings$TracingConfiguration") + o.enabled = property.NewPrimitive[bool]("Enabled", property.DecodeBool) + o.enabled.Bind(&o.Base, 0) + o.serviceName = property.NewPrimitive[string]("ServiceName", property.DecodeString) + o.serviceName.Bind(&o.Base, 1) + o.endpoint = property.NewPrimitive[string]("Endpoint", property.DecodeString) + o.endpoint.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.enabled, o.serviceName, o.endpoint}) + return o +} + +// NewTracingConfiguration creates a new TracingConfiguration for user code. Marked dirty (bit 63 = new element). +func NewTracingConfiguration() *TracingConfiguration { + o := initTracingConfiguration() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUserLibJarLocation creates a UserLibJarLocation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUserLibJarLocation() *UserLibJarLocation { + o := &UserLibJarLocation{} + o.SetTypeName("Settings$UserLibJarLocation") + o.jarFileName = property.NewPrimitive[string]("JarFileName", property.DecodeString) + o.jarFileName.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.jarFileName}) + return o +} + +// NewUserLibJarLocation creates a new UserLibJarLocation for user code. Marked dirty (bit 63 = new element). +func NewUserLibJarLocation() *UserLibJarLocation { + o := initUserLibJarLocation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWebUIProjectSettingsPart creates a WebUIProjectSettingsPart with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWebUIProjectSettingsPart() *WebUIProjectSettingsPart { + o := &WebUIProjectSettingsPart{} + o.SetTypeName("Forms$WebUIProjectSettingsPart") + o.useOptimizedClient = property.NewEnum[string]("UseOptimizedClient") + o.useOptimizedClient.Bind(&o.Base, 0) + o.urlPrefix = property.NewPrimitive[string]("UrlPrefix", property.DecodeString) + o.urlPrefix.Bind(&o.Base, 1) + o.theme = property.NewPrimitive[string]("Theme", property.DecodeString) + o.theme.Bind(&o.Base, 2) + o.themeModuleName = property.NewPrimitive[string]("ThemeModuleName", property.DecodeString) + o.themeModuleName.Bind(&o.Base, 3) + o.feedbackWidgetUpdated = property.NewPrimitive[bool]("FeedbackWidgetUpdated", property.DecodeBool) + o.feedbackWidgetUpdated.Bind(&o.Base, 4) + o.enableWidgetBundling = property.NewPrimitive[bool]("EnableWidgetBundling", property.DecodeBool) + o.enableWidgetBundling.Bind(&o.Base, 5) + o.enableDownloadResources = property.NewPrimitive[bool]("EnableDownloadResources", property.DecodeBool) + o.enableDownloadResources.Bind(&o.Base, 6) + o.enableMicroflowReachabilityAnalysis = property.NewPrimitive[bool]("EnableMicroflowReachabilityAnalysis", property.DecodeBool) + o.enableMicroflowReachabilityAnalysis.Bind(&o.Base, 7) + o.themeConversionStatus = property.NewEnum[string]("ThemeConversionStatus") + o.themeConversionStatus.Bind(&o.Base, 8) + o.themeModuleOrder = property.NewPartList[element.Element]("ThemeModuleOrder") + o.themeModuleOrder.Bind(&o.Base, 9) + o.enableNewWidgetGeneration = property.NewPrimitive[bool]("EnableNewWidgetGeneration", property.DecodeBool) + o.enableNewWidgetGeneration.Bind(&o.Base, 10) + o.enableNewStringBehavior = property.NewPrimitive[bool]("EnableNewStringBehavior", property.DecodeBool) + o.enableNewStringBehavior.Bind(&o.Base, 11) + o.exportEmbeddedEntrypoint = property.NewPrimitive[bool]("ExportEmbeddedEntrypoint", property.DecodeBool) + o.exportEmbeddedEntrypoint.Bind(&o.Base, 12) + o.enableRspackBundler = property.NewPrimitive[bool]("EnableRspackBundler", property.DecodeBool) + o.enableRspackBundler.Bind(&o.Base, 13) + o.SetProperties([]element.Property{o.useOptimizedClient, o.urlPrefix, o.theme, o.themeModuleName, o.feedbackWidgetUpdated, o.enableWidgetBundling, o.enableDownloadResources, o.enableMicroflowReachabilityAnalysis, o.themeConversionStatus, o.themeModuleOrder, o.enableNewWidgetGeneration, o.enableNewStringBehavior, o.exportEmbeddedEntrypoint, o.enableRspackBundler}) + return o +} + +// NewWebUIProjectSettingsPart creates a new WebUIProjectSettingsPart for user code. Marked dirty (bit 63 = new element). +func NewWebUIProjectSettingsPart() *WebUIProjectSettingsPart { + o := initWebUIProjectSettingsPart() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowGroup creates a WorkflowGroup with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowGroup() *WorkflowGroup { + o := &WorkflowGroup{} + o.SetTypeName("Settings$WorkflowGroup") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.description}) + return o +} + +// NewWorkflowGroup creates a new WorkflowGroup for user code. Marked dirty (bit 63 = new element). +func NewWorkflowGroup() *WorkflowGroup { + o := initWorkflowGroup() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowsProjectSettingsPart creates a WorkflowsProjectSettingsPart with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowsProjectSettingsPart() *WorkflowsProjectSettingsPart { + o := &WorkflowsProjectSettingsPart{} + o.SetTypeName("Settings$WorkflowsProjectSettingsPart") + o.enabled = property.NewPrimitive[bool]("Enabled", property.DecodeBool) + o.enabled.Bind(&o.Base, 0) + o.userEntity = property.NewByNameRef[element.Element]("UserEntity", "DomainModels$Entity") + o.userEntity.Bind(&o.Base, 1) + o.groups = property.NewPartList[element.Element]("Groups") + o.groups.Bind(&o.Base, 2) + o.workflowEngineParallelism = property.NewPrimitive[int32]("WorkflowEngineParallelism", property.DecodeInt32) + o.workflowEngineParallelism.Bind(&o.Base, 3) + o.defaultTaskParallelism = property.NewPrimitive[int32]("DefaultTaskParallelism", property.DecodeInt32) + o.defaultTaskParallelism.Bind(&o.Base, 4) + o.workflowOnStateChangeEvent = property.NewPart[element.Element]("WorkflowOnStateChangeEvent") + o.workflowOnStateChangeEvent.Bind(&o.Base, 5) + o.usertaskOnStateChangeEvent = property.NewPart[element.Element]("UsertaskOnStateChangeEvent") + o.usertaskOnStateChangeEvent.Bind(&o.Base, 6) + o.onWorkflowEvent = property.NewPartList[element.Element]("OnWorkflowEvent") + o.onWorkflowEvent.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.enabled, o.userEntity, o.groups, o.workflowEngineParallelism, o.defaultTaskParallelism, o.workflowOnStateChangeEvent, o.usertaskOnStateChangeEvent, o.onWorkflowEvent}) + return o +} + +// NewWorkflowsProjectSettingsPart creates a new WorkflowsProjectSettingsPart for user code. Marked dirty (bit 63 = new element). +func NewWorkflowsProjectSettingsPart() *WorkflowsProjectSettingsPart { + o := initWorkflowsProjectSettingsPart() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Settings$ActionActivityDefaultColor", func() element.Element { + return initActionActivityDefaultColor() + }) + codec.DefaultRegistry.Register("Settings$Certificate", func() element.Element { + return initCertificate() + }) + codec.DefaultRegistry.Register("Settings$CertificateSettings", func() element.Element { + return initCertificateSettings() + }) + codec.DefaultRegistry.Register("Settings$Configuration", func() element.Element { + return initConfiguration() + }) + codec.DefaultRegistry.Register("Settings$ConfigurationSettings", func() element.Element { + return initConfigurationSettings() + }) + codec.DefaultRegistry.Register("Settings$ConstantValue", func() element.Element { + return initConstantValue() + }) + codec.DefaultRegistry.Register("Settings$CustomSetting", func() element.Element { + return initCustomSetting() + }) + codec.DefaultRegistry.Register("Settings$DistributionSettings", func() element.Element { + return initDistributionSettings() + }) + codec.DefaultRegistry.Register("Settings$IntegrationProjectSettingsPart", func() element.Element { + return initIntegrationProjectSettingsPart() + }) + codec.DefaultRegistry.Register("Settings$JarDeploymentSettings", func() element.Element { + return initJarDeploymentSettings() + }) + codec.DefaultRegistry.Register("Settings$JavaActionsSettings", func() element.Element { + return initJavaActionsSettings() + }) + codec.DefaultRegistry.Register("Settings$Language", func() element.Element { + o := initLanguage() + o.SetTypeName("Settings$Language") + return o + }) + codec.DefaultRegistry.Register("Texts$Language", func() element.Element { + return initLanguage() + }) + codec.DefaultRegistry.Register("Settings$LanguageSettings", func() element.Element { + return initLanguageSettings() + }) + codec.DefaultRegistry.Register("Settings$ModelerSettings", func() element.Element { + return initModelerSettings() + }) + codec.DefaultRegistry.Register("Settings$PrivateValue", func() element.Element { + return initPrivateValue() + }) + codec.DefaultRegistry.Register("Settings$ProjectSettings", func() element.Element { + return initProjectSettings() + }) + codec.DefaultRegistry.Register("Settings$ProtectedModuleJarLocation", func() element.Element { + return initProtectedModuleJarLocation() + }) + codec.DefaultRegistry.Register("Settings$RuntimeSettings", func() element.Element { + return initRuntimeSettings() + }) + codec.DefaultRegistry.Register("Settings$SharedValue", func() element.Element { + return initSharedValue() + }) + codec.DefaultRegistry.Register("Settings$ThemeModuleEntry", func() element.Element { + return initThemeModuleEntry() + }) + codec.DefaultRegistry.Register("Settings$TracingConfiguration", func() element.Element { + return initTracingConfiguration() + }) + codec.DefaultRegistry.Register("Settings$UserLibJarLocation", func() element.Element { + return initUserLibJarLocation() + }) + codec.DefaultRegistry.Register("Settings$WebUIProjectSettingsPart", func() element.Element { + o := initWebUIProjectSettingsPart() + o.SetTypeName("Settings$WebUIProjectSettingsPart") + return o + }) + codec.DefaultRegistry.Register("Forms$WebUIProjectSettingsPart", func() element.Element { + return initWebUIProjectSettingsPart() + }) + codec.DefaultRegistry.Register("Settings$WorkflowGroup", func() element.Element { + return initWorkflowGroup() + }) + codec.DefaultRegistry.Register("Settings$WorkflowsProjectSettingsPart", func() element.Element { + return initWorkflowsProjectSettingsPart() + }) +} diff --git a/modelsdk/gen/settings/version.go b/modelsdk/gen/settings/version.go new file mode 100644 index 00000000..06af12b9 --- /dev/null +++ b/modelsdk/gen/settings/version.go @@ -0,0 +1,97 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package settings + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Settings$Configuration": { + Properties: map[string]version.PropertyVersionInfo{ + "emulateCloudSecurity": {Deleted: "7.21.0"}, + "tracing": {Introduced: "10.21.0"}, + }, + }, + "Settings$ConstantValue": { + Properties: map[string]version.PropertyVersionInfo{ + "constant": {Required: true}, + "sharedOrPrivateValue": {Introduced: "10.9.0", Required: true}, + "value": {Deleted: "10.9.0"}, + }, + }, + "Settings$IntegrationProjectSettingsPart": { + Properties: map[string]version.PropertyVersionInfo{ + "obsoleteEnableUrlEncoding": {Introduced: "10.21.0", Deleted: "11.0.0"}, + }, + }, + "Settings$ModelerSettings": { + Properties: map[string]version.PropertyVersionInfo{ + "actionActivityDefaultColors": {Introduced: "8.6.0"}, + "defaultAssociationStorage": {Introduced: "10.21.0"}, + "defaultSequenceFlowLineType": {Introduced: "10.8.0"}, + }, + }, + "Settings$RuntimeSettings": { + Properties: map[string]version.PropertyVersionInfo{ + "bcryptCost": {Introduced: "9.11.0"}, + "decimalScale": {Introduced: "11.4.0"}, + "enableDataStorageNewQueryHandling": {Introduced: "7.10.0", Deleted: "8.0.0"}, + "enableDataStorageOptimisticLocking": {Introduced: "7.5.0"}, + "enforceDataStorageUniqueness": {Introduced: "7.1.0", Deleted: "9.0.2"}, + "javaVersion": {Introduced: "10.8.0"}, + "sslCertificateAlgorithm": {Introduced: "10.21.0"}, + "useDatabaseForeignKeyConstraints": {Introduced: "10.6.0"}, + "useDeprecatedClientForWebServiceCalls": {Introduced: "7.15.0", Deleted: "8.0.0"}, + "useOQLVersion2": {Introduced: "10.11.0"}, + "useSystemContextForBackgroundTasks": {Introduced: "9.6.0"}, + }, + }, + "Settings$WebUIProjectSettingsPart": { + Properties: map[string]version.PropertyVersionInfo{ + "enableDownloadResources": {Introduced: "6.6.0", Deleted: "10.0.0"}, + "enableMicroflowReachabilityAnalysis": {Introduced: "7.0.2"}, + "enableNewStringBehavior": {Introduced: "11.6.0"}, + "enableNewWidgetGeneration": {Introduced: "10.6.0"}, + "enableRspackBundler": {Introduced: "11.9.0"}, + "exportEmbeddedEntrypoint": {Introduced: "11.8.0"}, + "feedbackWidgetUpdated": {Deleted: "6.2.0"}, + "theme": {Deleted: "9.2.0"}, + "themeConversionStatus": {Introduced: "8.0.0", Deleted: "9.0.1"}, + "themeModuleName": {Introduced: "7.9.0", Deleted: "9.2.0"}, + "themeModuleOrder": {Introduced: "9.3.0"}, + "urlPrefix": {Introduced: "10.5.0"}, + "useOptimizedClient": {Introduced: "9.10.0"}, + }, + }, + "Forms$WebUIProjectSettingsPart": { + Properties: map[string]version.PropertyVersionInfo{ + "enableDownloadResources": {Introduced: "6.6.0", Deleted: "10.0.0"}, + "enableMicroflowReachabilityAnalysis": {Introduced: "7.0.2"}, + "enableNewStringBehavior": {Introduced: "11.6.0"}, + "enableNewWidgetGeneration": {Introduced: "10.6.0"}, + "enableRspackBundler": {Introduced: "11.9.0"}, + "exportEmbeddedEntrypoint": {Introduced: "11.8.0"}, + "feedbackWidgetUpdated": {Deleted: "6.2.0"}, + "theme": {Deleted: "9.2.0"}, + "themeConversionStatus": {Introduced: "8.0.0", Deleted: "9.0.1"}, + "themeModuleName": {Introduced: "7.9.0", Deleted: "9.2.0"}, + "themeModuleOrder": {Introduced: "9.3.0"}, + "urlPrefix": {Introduced: "10.5.0"}, + "useOptimizedClient": {Introduced: "9.10.0"}, + }, + }, + "Settings$WorkflowsProjectSettingsPart": { + Properties: map[string]version.PropertyVersionInfo{ + "defaultTaskParallelism": {Introduced: "9.0.5"}, + "enabled": {Deleted: "9.0.5"}, + "groups": {Introduced: "11.2.0"}, + "onWorkflowEvent": {Introduced: "10.7.0"}, + "userEntity": {Introduced: "8.11.0"}, + "usertaskOnStateChangeEvent": {Introduced: "9.12.0", Deleted: "11.0.0"}, + "workflowEngineParallelism": {Introduced: "9.0.5"}, + "workflowOnStateChangeEvent": {Introduced: "9.12.0", Deleted: "11.0.0"}, + }, + }, +} diff --git a/modelsdk/gen/texts/enums.go b/modelsdk/gen/texts/enums.go new file mode 100644 index 00000000..ded626b6 --- /dev/null +++ b/modelsdk/gen/texts/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package texts diff --git a/modelsdk/gen/texts/refs.go b/modelsdk/gen/texts/refs.go new file mode 100644 index 00000000..ded626b6 --- /dev/null +++ b/modelsdk/gen/texts/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package texts diff --git a/modelsdk/gen/texts/types.go b/modelsdk/gen/texts/types.go new file mode 100644 index 00000000..97e4b73b --- /dev/null +++ b/modelsdk/gen/texts/types.go @@ -0,0 +1,267 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package texts + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// SystemText +// ──────────────────────────────────────────────────────── + +type SystemText struct { + element.Base + text *property.Part[element.Element] + key *property.Primitive[string] +} + +// Text returns the value of the text property. +func (o *SystemText) Text() element.Element { + return o.text.Get() +} + +// SetText sets the value of the text property. +func (o *SystemText) SetText(v element.Element) { + o.text.Set(v) +} + +// Key returns the value of the key property. +func (o *SystemText) Key() string { + return o.key.Get() +} + +// SetKey sets the value of the key property. +func (o *SystemText) SetKey(v string) { + o.key.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SystemText) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "Text"); err == nil { + o.text.SetFromDecode(child) + } + o.key.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SystemTextCollection +// ──────────────────────────────────────────────────────── + +type SystemTextCollection struct { + element.Base + systemTexts *property.PartList[element.Element] +} + +// SystemTextsItems returns the value of the systemTexts property. +func (o *SystemTextCollection) SystemTextsItems() []element.Element { + return o.systemTexts.Items() +} + +// AddSystemTexts appends a child element to the systemTexts list. +func (o *SystemTextCollection) AddSystemTexts(v element.Element) { + o.systemTexts.Append(v) +} + +// RemoveSystemTexts removes the element at the given index from the systemTexts list. +func (o *SystemTextCollection) RemoveSystemTexts(index int) { + o.systemTexts.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SystemTextCollection) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "SystemTexts"); err == nil { + for _, child := range children { + o.systemTexts.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Text +// ──────────────────────────────────────────────────────── + +type Text struct { + element.Base + translations *property.PartList[element.Element] +} + +// TranslationsItems returns the value of the translations property. +func (o *Text) TranslationsItems() []element.Element { + return o.translations.Items() +} + +// AddTranslations appends a child element to the translations list. +func (o *Text) AddTranslations(v element.Element) { + o.translations.Append(v) +} + +// RemoveTranslations removes the element at the given index from the translations list. +func (o *Text) RemoveTranslations(index int) { + o.translations.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Text) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Translations"); err == nil { + for _, child := range children { + o.translations.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// Translation +// ──────────────────────────────────────────────────────── + +type Translation struct { + element.Base + languageCode *property.Primitive[string] + text *property.Primitive[string] +} + +// LanguageCode returns the value of the languageCode property. +func (o *Translation) LanguageCode() string { + return o.languageCode.Get() +} + +// SetLanguageCode sets the value of the languageCode property. +func (o *Translation) SetLanguageCode(v string) { + o.languageCode.Set(v) +} + +// Text returns the value of the text property. +func (o *Translation) Text() string { + return o.text.Get() +} + +// SetText sets the value of the text property. +func (o *Translation) SetText(v string) { + o.text.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Translation) InitFromRaw(raw bson.Raw) { + o.languageCode.Init(raw) + o.text.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initSystemText creates a SystemText with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSystemText() *SystemText { + o := &SystemText{} + o.SetTypeName("Texts$SystemText") + o.text = property.NewPart[element.Element]("Text") + o.text.Bind(&o.Base, 0) + o.key = property.NewPrimitive[string]("Key", property.DecodeString) + o.key.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.text, o.key}) + return o +} + +// NewSystemText creates a new SystemText for user code. Marked dirty (bit 63 = new element). +func NewSystemText() *SystemText { + o := initSystemText() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSystemTextCollection creates a SystemTextCollection with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSystemTextCollection() *SystemTextCollection { + o := &SystemTextCollection{} + o.SetTypeName("Texts$SystemTextCollection") + o.systemTexts = property.NewPartList[element.Element]("SystemTexts") + o.systemTexts.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.systemTexts}) + return o +} + +// NewSystemTextCollection creates a new SystemTextCollection for user code. Marked dirty (bit 63 = new element). +func NewSystemTextCollection() *SystemTextCollection { + o := initSystemTextCollection() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initText creates a Text with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initText() *Text { + o := &Text{} + o.SetTypeName("Texts$Text") + o.translations = property.NewPartList[element.Element]("Translations") + o.translations.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.translations}) + return o +} + +// NewText creates a new Text for user code. Marked dirty (bit 63 = new element). +func NewText() *Text { + o := initText() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTranslation creates a Translation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTranslation() *Translation { + o := &Translation{} + o.SetTypeName("Texts$Translation") + o.languageCode = property.NewPrimitive[string]("LanguageCode", property.DecodeString) + o.languageCode.Bind(&o.Base, 0) + o.text = property.NewPrimitive[string]("Text", property.DecodeString) + o.text.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.languageCode, o.text}) + return o +} + +// NewTranslation creates a new Translation for user code. Marked dirty (bit 63 = new element). +func NewTranslation() *Translation { + o := initTranslation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Texts$SystemText", func() element.Element { + return initSystemText() + }) + codec.DefaultRegistry.Register("Texts$SystemTextCollection", func() element.Element { + return initSystemTextCollection() + }) + codec.DefaultRegistry.Register("Texts$Text", func() element.Element { + return initText() + }) + codec.DefaultRegistry.Register("Texts$Translation", func() element.Element { + return initTranslation() + }) +} diff --git a/modelsdk/gen/texts/version.go b/modelsdk/gen/texts/version.go new file mode 100644 index 00000000..b8853a30 --- /dev/null +++ b/modelsdk/gen/texts/version.go @@ -0,0 +1,21 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package texts + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Texts$SystemText": { + Properties: map[string]version.PropertyVersionInfo{ + "text": {Required: true}, + }, + }, + "Texts$Text": { + Properties: map[string]version.PropertyVersionInfo{ + "translations": {}, + }, + }, +} diff --git a/modelsdk/gen/url/enums.go b/modelsdk/gen/url/enums.go new file mode 100644 index 00000000..7fdd8387 --- /dev/null +++ b/modelsdk/gen/url/enums.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package url diff --git a/modelsdk/gen/url/refs.go b/modelsdk/gen/url/refs.go new file mode 100644 index 00000000..7fdd8387 --- /dev/null +++ b/modelsdk/gen/url/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package url diff --git a/modelsdk/gen/url/types.go b/modelsdk/gen/url/types.go new file mode 100644 index 00000000..5476bd9a --- /dev/null +++ b/modelsdk/gen/url/types.go @@ -0,0 +1,87 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package url + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// UrlSegment +// ──────────────────────────────────────────────────────── + +type UrlSegment struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UrlSegment) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// StaticUrlSegment +// ──────────────────────────────────────────────────────── + +type StaticUrlSegment struct { + element.Base + segment *property.Primitive[string] +} + +// Segment returns the value of the segment property. +func (o *StaticUrlSegment) Segment() string { + return o.segment.Get() +} + +// SetSegment sets the value of the segment property. +func (o *StaticUrlSegment) SetSegment(v string) { + o.segment.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StaticUrlSegment) InitFromRaw(raw bson.Raw) { + o.segment.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initStaticUrlSegment creates a StaticUrlSegment with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStaticUrlSegment() *StaticUrlSegment { + o := &StaticUrlSegment{} + o.SetTypeName("Url$StaticUrlSegment") + o.segment = property.NewPrimitive[string]("Segment", property.DecodeString) + o.segment.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.segment}) + return o +} + +// NewStaticUrlSegment creates a new StaticUrlSegment for user code. Marked dirty (bit 63 = new element). +func NewStaticUrlSegment() *StaticUrlSegment { + o := initStaticUrlSegment() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("Url$StaticUrlSegment", func() element.Element { + return initStaticUrlSegment() + }) +} diff --git a/modelsdk/gen/url/version.go b/modelsdk/gen/url/version.go new file mode 100644 index 00000000..c9b6875a --- /dev/null +++ b/modelsdk/gen/url/version.go @@ -0,0 +1,10 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package url + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{} diff --git a/modelsdk/gen/webservices/enums.go b/modelsdk/gen/webservices/enums.go new file mode 100644 index 00000000..f6cf3309 --- /dev/null +++ b/modelsdk/gen/webservices/enums.go @@ -0,0 +1,31 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package webservices + +// AppServiceState enumerates the possible values for the AppServiceState type. +type AppServiceState = string + +const ( + AppServiceStateDraft AppServiceState = "Draft" + AppServiceStateConsumable AppServiceState = "Consumable" + AppServiceStateDeprecated AppServiceState = "Deprecated" +) + +// HeaderAuthentication enumerates the possible values for the HeaderAuthentication type. +type HeaderAuthentication = string + +const ( + HeaderAuthenticationNone HeaderAuthentication = "None" + HeaderAuthenticationUsernamePassword HeaderAuthentication = "UsernamePassword" + HeaderAuthenticationCustom HeaderAuthentication = "Custom" +) + +// SoapVersion enumerates the possible values for the SoapVersion type. +type SoapVersion = string + +const ( + SoapVersionSoap11 SoapVersion = "Soap11" + SoapVersionSoap12 SoapVersion = "Soap12" +) diff --git a/modelsdk/gen/webservices/refs.go b/modelsdk/gen/webservices/refs.go new file mode 100644 index 00000000..4373f1b3 --- /dev/null +++ b/modelsdk/gen/webservices/refs.go @@ -0,0 +1,60 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package webservices + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("WebServices$DataEntityBase", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$DataAssociation", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$DataAssociationImpl", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Association", Kind: codec.RefByName, Target: "DomainModels$AssociationBase"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$DataAttribute", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$DataAttributeImpl", []codec.RefMeta{ + {Prop: "Attribute", Kind: codec.RefByName, Target: "DomainModels$Attribute"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$DataEntity", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$DataEntityImpl", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$PublishedOperation", []codec.RefMeta{ + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$PublishedOperationImpl", []codec.RefMeta{ + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$PublishedParameter", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$ServiceInfo", []codec.RefMeta{ + {Prop: "LocationConstant", Kind: codec.RefByName, Target: "Constants$Constant"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$SystemIdDataAttribute", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$VersionedService", []codec.RefMeta{ + {Prop: "HeaderImportMapping", Kind: codec.RefByName, Target: "ImportMappings$ImportMapping"}, + {Prop: "HeaderMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + }) + codec.DefaultRefRegistry.RegisterRefs("WebServices$VersionedServiceImpl", []codec.RefMeta{ + {Prop: "HeaderImportMapping", Kind: codec.RefByName, Target: "ImportMappings$ImportMapping"}, + {Prop: "HeaderMicroflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + {Prop: "Image", Kind: codec.RefByName, Target: "Images$Image"}, + }) +} diff --git a/modelsdk/gen/webservices/types.go b/modelsdk/gen/webservices/types.go new file mode 100644 index 00000000..3e782ef2 --- /dev/null +++ b/modelsdk/gen/webservices/types.go @@ -0,0 +1,3269 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package webservices + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// DataMember +// ──────────────────────────────────────────────────────── + +type DataMember struct { + element.Base + isLockedByContract *property.Primitive[bool] + exposedName *property.Primitive[string] + isOptionalByContract *property.Primitive[bool] + isOptional *property.Primitive[bool] + isNillableByContract *property.Primitive[bool] + isNillable *property.Primitive[bool] + isKey *property.Primitive[bool] +} + +// IsLockedByContract returns the value of the isLockedByContract property. +func (o *DataMember) IsLockedByContract() bool { + return o.isLockedByContract.Get() +} + +// SetIsLockedByContract sets the value of the isLockedByContract property. +func (o *DataMember) SetIsLockedByContract(v bool) { + o.isLockedByContract.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *DataMember) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *DataMember) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// IsOptionalByContract returns the value of the isOptionalByContract property. +func (o *DataMember) IsOptionalByContract() bool { + return o.isOptionalByContract.Get() +} + +// SetIsOptionalByContract sets the value of the isOptionalByContract property. +func (o *DataMember) SetIsOptionalByContract(v bool) { + o.isOptionalByContract.Set(v) +} + +// IsOptional returns the value of the isOptional property. +func (o *DataMember) IsOptional() bool { + return o.isOptional.Get() +} + +// SetIsOptional sets the value of the isOptional property. +func (o *DataMember) SetIsOptional(v bool) { + o.isOptional.Set(v) +} + +// IsNillableByContract returns the value of the isNillableByContract property. +func (o *DataMember) IsNillableByContract() bool { + return o.isNillableByContract.Get() +} + +// SetIsNillableByContract sets the value of the isNillableByContract property. +func (o *DataMember) SetIsNillableByContract(v bool) { + o.isNillableByContract.Set(v) +} + +// IsNillable returns the value of the isNillable property. +func (o *DataMember) IsNillable() bool { + return o.isNillable.Get() +} + +// SetIsNillable sets the value of the isNillable property. +func (o *DataMember) SetIsNillable(v bool) { + o.isNillable.Set(v) +} + +// IsKey returns the value of the isKey property. +func (o *DataMember) IsKey() bool { + return o.isKey.Get() +} + +// SetIsKey sets the value of the isKey property. +func (o *DataMember) SetIsKey(v bool) { + o.isKey.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataMember) InitFromRaw(raw bson.Raw) { + o.isLockedByContract.Init(raw) + o.exposedName.Init(raw) + o.isOptionalByContract.Init(raw) + o.isOptional.Init(raw) + o.isNillableByContract.Init(raw) + o.isNillable.Init(raw) + o.isKey.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataEntityBase +// ──────────────────────────────────────────────────────── + +type DataEntityBase struct { + element.Base + isLockedByContract *property.Primitive[bool] + exposedName *property.Primitive[string] + isOptionalByContract *property.Primitive[bool] + isOptional *property.Primitive[bool] + isNillableByContract *property.Primitive[bool] + isNillable *property.Primitive[bool] + isKey *property.Primitive[bool] + childMembers *property.PartList[element.Element] + entity *property.ByNameRef[element.Element] + exposedItemName *property.Primitive[string] +} + +// IsLockedByContract returns the value of the isLockedByContract property. +func (o *DataEntityBase) IsLockedByContract() bool { + return o.isLockedByContract.Get() +} + +// SetIsLockedByContract sets the value of the isLockedByContract property. +func (o *DataEntityBase) SetIsLockedByContract(v bool) { + o.isLockedByContract.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *DataEntityBase) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *DataEntityBase) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// IsOptionalByContract returns the value of the isOptionalByContract property. +func (o *DataEntityBase) IsOptionalByContract() bool { + return o.isOptionalByContract.Get() +} + +// SetIsOptionalByContract sets the value of the isOptionalByContract property. +func (o *DataEntityBase) SetIsOptionalByContract(v bool) { + o.isOptionalByContract.Set(v) +} + +// IsOptional returns the value of the isOptional property. +func (o *DataEntityBase) IsOptional() bool { + return o.isOptional.Get() +} + +// SetIsOptional sets the value of the isOptional property. +func (o *DataEntityBase) SetIsOptional(v bool) { + o.isOptional.Set(v) +} + +// IsNillableByContract returns the value of the isNillableByContract property. +func (o *DataEntityBase) IsNillableByContract() bool { + return o.isNillableByContract.Get() +} + +// SetIsNillableByContract sets the value of the isNillableByContract property. +func (o *DataEntityBase) SetIsNillableByContract(v bool) { + o.isNillableByContract.Set(v) +} + +// IsNillable returns the value of the isNillable property. +func (o *DataEntityBase) IsNillable() bool { + return o.isNillable.Get() +} + +// SetIsNillable sets the value of the isNillable property. +func (o *DataEntityBase) SetIsNillable(v bool) { + o.isNillable.Set(v) +} + +// IsKey returns the value of the isKey property. +func (o *DataEntityBase) IsKey() bool { + return o.isKey.Get() +} + +// SetIsKey sets the value of the isKey property. +func (o *DataEntityBase) SetIsKey(v bool) { + o.isKey.Set(v) +} + +// ChildMembersItems returns the value of the childMembers property. +func (o *DataEntityBase) ChildMembersItems() []element.Element { + return o.childMembers.Items() +} + +// AddChildMembers appends a child element to the childMembers list. +func (o *DataEntityBase) AddChildMembers(v element.Element) { + o.childMembers.Append(v) +} + +// RemoveChildMembers removes the element at the given index from the childMembers list. +func (o *DataEntityBase) RemoveChildMembers(index int) { + o.childMembers.Remove(index) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *DataEntityBase) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *DataEntityBase) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *DataEntityBase) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *DataEntityBase) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataEntityBase) InitFromRaw(raw bson.Raw) { + o.isLockedByContract.Init(raw) + o.exposedName.Init(raw) + o.isOptionalByContract.Init(raw) + o.isOptional.Init(raw) + o.isNillableByContract.Init(raw) + o.isNillable.Init(raw) + o.isKey.Init(raw) + if children, err := codec.DecodeChildren(raw, "ChildMembers"); err == nil { + for _, child := range children { + o.childMembers.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + o.exposedItemName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataAssociation +// ──────────────────────────────────────────────────────── + +type DataAssociation struct { + element.Base + isLockedByContract *property.Primitive[bool] + exposedName *property.Primitive[string] + isOptionalByContract *property.Primitive[bool] + isOptional *property.Primitive[bool] + isNillableByContract *property.Primitive[bool] + isNillable *property.Primitive[bool] + isKey *property.Primitive[bool] + childMembers *property.PartList[element.Element] + entity *property.ByNameRef[element.Element] + exposedItemName *property.Primitive[string] + associationByContract *property.Part[element.Element] + association *property.ByNameRef[element.Element] + exposedAssociationName *property.Primitive[string] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// IsLockedByContract returns the value of the isLockedByContract property. +func (o *DataAssociation) IsLockedByContract() bool { + return o.isLockedByContract.Get() +} + +// SetIsLockedByContract sets the value of the isLockedByContract property. +func (o *DataAssociation) SetIsLockedByContract(v bool) { + o.isLockedByContract.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *DataAssociation) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *DataAssociation) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// IsOptionalByContract returns the value of the isOptionalByContract property. +func (o *DataAssociation) IsOptionalByContract() bool { + return o.isOptionalByContract.Get() +} + +// SetIsOptionalByContract sets the value of the isOptionalByContract property. +func (o *DataAssociation) SetIsOptionalByContract(v bool) { + o.isOptionalByContract.Set(v) +} + +// IsOptional returns the value of the isOptional property. +func (o *DataAssociation) IsOptional() bool { + return o.isOptional.Get() +} + +// SetIsOptional sets the value of the isOptional property. +func (o *DataAssociation) SetIsOptional(v bool) { + o.isOptional.Set(v) +} + +// IsNillableByContract returns the value of the isNillableByContract property. +func (o *DataAssociation) IsNillableByContract() bool { + return o.isNillableByContract.Get() +} + +// SetIsNillableByContract sets the value of the isNillableByContract property. +func (o *DataAssociation) SetIsNillableByContract(v bool) { + o.isNillableByContract.Set(v) +} + +// IsNillable returns the value of the isNillable property. +func (o *DataAssociation) IsNillable() bool { + return o.isNillable.Get() +} + +// SetIsNillable sets the value of the isNillable property. +func (o *DataAssociation) SetIsNillable(v bool) { + o.isNillable.Set(v) +} + +// IsKey returns the value of the isKey property. +func (o *DataAssociation) IsKey() bool { + return o.isKey.Get() +} + +// SetIsKey sets the value of the isKey property. +func (o *DataAssociation) SetIsKey(v bool) { + o.isKey.Set(v) +} + +// ChildMembersItems returns the value of the childMembers property. +func (o *DataAssociation) ChildMembersItems() []element.Element { + return o.childMembers.Items() +} + +// AddChildMembers appends a child element to the childMembers list. +func (o *DataAssociation) AddChildMembers(v element.Element) { + o.childMembers.Append(v) +} + +// RemoveChildMembers removes the element at the given index from the childMembers list. +func (o *DataAssociation) RemoveChildMembers(index int) { + o.childMembers.Remove(index) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *DataAssociation) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *DataAssociation) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *DataAssociation) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *DataAssociation) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// AssociationByContract returns the value of the associationByContract property. +func (o *DataAssociation) AssociationByContract() element.Element { + return o.associationByContract.Get() +} + +// SetAssociationByContract sets the value of the associationByContract property. +func (o *DataAssociation) SetAssociationByContract(v element.Element) { + o.associationByContract.Set(v) +} + +// AssociationQualifiedName returns the value of the association property. +func (o *DataAssociation) AssociationQualifiedName() string { + return o.association.QualifiedName() +} + +// SetAssociationQualifiedName sets the value of the association property. +func (o *DataAssociation) SetAssociationQualifiedName(v string) { + o.association.SetQualifiedName(v) +} + +// ExposedAssociationName returns the value of the exposedAssociationName property. +func (o *DataAssociation) ExposedAssociationName() string { + return o.exposedAssociationName.Get() +} + +// SetExposedAssociationName sets the value of the exposedAssociationName property. +func (o *DataAssociation) SetExposedAssociationName(v string) { + o.exposedAssociationName.Set(v) +} + +// Summary returns the value of the summary property. +func (o *DataAssociation) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *DataAssociation) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *DataAssociation) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *DataAssociation) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataAssociation) InitFromRaw(raw bson.Raw) { + o.isLockedByContract.Init(raw) + o.exposedName.Init(raw) + o.isOptionalByContract.Init(raw) + o.isOptional.Init(raw) + o.isNillableByContract.Init(raw) + o.isNillable.Init(raw) + o.isKey.Init(raw) + if children, err := codec.DecodeChildren(raw, "ChildMembers"); err == nil { + for _, child := range children { + o.childMembers.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + o.exposedItemName.Init(raw) + if child, err := codec.DecodeChild(raw, "AssociationByContract"); err == nil { + o.associationByContract.SetFromDecode(child) + } + if val, err := raw.LookupErr("Association"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.association.SetFromDecode(s) + } + } + o.exposedAssociationName.Init(raw) + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataAttribute +// ──────────────────────────────────────────────────────── + +type DataAttribute struct { + element.Base + isLockedByContract *property.Primitive[bool] + exposedName *property.Primitive[string] + isOptionalByContract *property.Primitive[bool] + isOptional *property.Primitive[bool] + isNillableByContract *property.Primitive[bool] + isNillable *property.Primitive[bool] + isKey *property.Primitive[bool] + attributeByContract *property.Part[element.Element] + attribute *property.ByNameRef[element.Element] + summary *property.Primitive[string] + description *property.Primitive[string] + filterable *property.Primitive[bool] + sortable *property.Primitive[bool] + enumerationAsString *property.Primitive[bool] +} + +// IsLockedByContract returns the value of the isLockedByContract property. +func (o *DataAttribute) IsLockedByContract() bool { + return o.isLockedByContract.Get() +} + +// SetIsLockedByContract sets the value of the isLockedByContract property. +func (o *DataAttribute) SetIsLockedByContract(v bool) { + o.isLockedByContract.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *DataAttribute) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *DataAttribute) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// IsOptionalByContract returns the value of the isOptionalByContract property. +func (o *DataAttribute) IsOptionalByContract() bool { + return o.isOptionalByContract.Get() +} + +// SetIsOptionalByContract sets the value of the isOptionalByContract property. +func (o *DataAttribute) SetIsOptionalByContract(v bool) { + o.isOptionalByContract.Set(v) +} + +// IsOptional returns the value of the isOptional property. +func (o *DataAttribute) IsOptional() bool { + return o.isOptional.Get() +} + +// SetIsOptional sets the value of the isOptional property. +func (o *DataAttribute) SetIsOptional(v bool) { + o.isOptional.Set(v) +} + +// IsNillableByContract returns the value of the isNillableByContract property. +func (o *DataAttribute) IsNillableByContract() bool { + return o.isNillableByContract.Get() +} + +// SetIsNillableByContract sets the value of the isNillableByContract property. +func (o *DataAttribute) SetIsNillableByContract(v bool) { + o.isNillableByContract.Set(v) +} + +// IsNillable returns the value of the isNillable property. +func (o *DataAttribute) IsNillable() bool { + return o.isNillable.Get() +} + +// SetIsNillable sets the value of the isNillable property. +func (o *DataAttribute) SetIsNillable(v bool) { + o.isNillable.Set(v) +} + +// IsKey returns the value of the isKey property. +func (o *DataAttribute) IsKey() bool { + return o.isKey.Get() +} + +// SetIsKey sets the value of the isKey property. +func (o *DataAttribute) SetIsKey(v bool) { + o.isKey.Set(v) +} + +// AttributeByContract returns the value of the attributeByContract property. +func (o *DataAttribute) AttributeByContract() element.Element { + return o.attributeByContract.Get() +} + +// SetAttributeByContract sets the value of the attributeByContract property. +func (o *DataAttribute) SetAttributeByContract(v element.Element) { + o.attributeByContract.Set(v) +} + +// AttributeQualifiedName returns the value of the attribute property. +func (o *DataAttribute) AttributeQualifiedName() string { + return o.attribute.QualifiedName() +} + +// SetAttributeQualifiedName sets the value of the attribute property. +func (o *DataAttribute) SetAttributeQualifiedName(v string) { + o.attribute.SetQualifiedName(v) +} + +// Summary returns the value of the summary property. +func (o *DataAttribute) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *DataAttribute) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *DataAttribute) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *DataAttribute) SetDescription(v string) { + o.description.Set(v) +} + +// Filterable returns the value of the filterable property. +func (o *DataAttribute) Filterable() bool { + return o.filterable.Get() +} + +// SetFilterable sets the value of the filterable property. +func (o *DataAttribute) SetFilterable(v bool) { + o.filterable.Set(v) +} + +// Sortable returns the value of the sortable property. +func (o *DataAttribute) Sortable() bool { + return o.sortable.Get() +} + +// SetSortable sets the value of the sortable property. +func (o *DataAttribute) SetSortable(v bool) { + o.sortable.Set(v) +} + +// EnumerationAsString returns the value of the enumerationAsString property. +func (o *DataAttribute) EnumerationAsString() bool { + return o.enumerationAsString.Get() +} + +// SetEnumerationAsString sets the value of the enumerationAsString property. +func (o *DataAttribute) SetEnumerationAsString(v bool) { + o.enumerationAsString.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataAttribute) InitFromRaw(raw bson.Raw) { + o.isLockedByContract.Init(raw) + o.exposedName.Init(raw) + o.isOptionalByContract.Init(raw) + o.isOptional.Init(raw) + o.isNillableByContract.Init(raw) + o.isNillable.Init(raw) + o.isKey.Init(raw) + if child, err := codec.DecodeChild(raw, "AttributeByContract"); err == nil { + o.attributeByContract.SetFromDecode(child) + } + if val, err := raw.LookupErr("Attribute"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.attribute.SetFromDecode(s) + } + } + o.summary.Init(raw) + o.description.Init(raw) + o.filterable.Init(raw) + o.sortable.Init(raw) + o.enumerationAsString.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// DataEntity +// ──────────────────────────────────────────────────────── + +type DataEntity struct { + element.Base + isLockedByContract *property.Primitive[bool] + exposedName *property.Primitive[string] + isOptionalByContract *property.Primitive[bool] + isOptional *property.Primitive[bool] + isNillableByContract *property.Primitive[bool] + isNillable *property.Primitive[bool] + isKey *property.Primitive[bool] + childMembers *property.PartList[element.Element] + entity *property.ByNameRef[element.Element] + exposedItemName *property.Primitive[string] +} + +// IsLockedByContract returns the value of the isLockedByContract property. +func (o *DataEntity) IsLockedByContract() bool { + return o.isLockedByContract.Get() +} + +// SetIsLockedByContract sets the value of the isLockedByContract property. +func (o *DataEntity) SetIsLockedByContract(v bool) { + o.isLockedByContract.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *DataEntity) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *DataEntity) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// IsOptionalByContract returns the value of the isOptionalByContract property. +func (o *DataEntity) IsOptionalByContract() bool { + return o.isOptionalByContract.Get() +} + +// SetIsOptionalByContract sets the value of the isOptionalByContract property. +func (o *DataEntity) SetIsOptionalByContract(v bool) { + o.isOptionalByContract.Set(v) +} + +// IsOptional returns the value of the isOptional property. +func (o *DataEntity) IsOptional() bool { + return o.isOptional.Get() +} + +// SetIsOptional sets the value of the isOptional property. +func (o *DataEntity) SetIsOptional(v bool) { + o.isOptional.Set(v) +} + +// IsNillableByContract returns the value of the isNillableByContract property. +func (o *DataEntity) IsNillableByContract() bool { + return o.isNillableByContract.Get() +} + +// SetIsNillableByContract sets the value of the isNillableByContract property. +func (o *DataEntity) SetIsNillableByContract(v bool) { + o.isNillableByContract.Set(v) +} + +// IsNillable returns the value of the isNillable property. +func (o *DataEntity) IsNillable() bool { + return o.isNillable.Get() +} + +// SetIsNillable sets the value of the isNillable property. +func (o *DataEntity) SetIsNillable(v bool) { + o.isNillable.Set(v) +} + +// IsKey returns the value of the isKey property. +func (o *DataEntity) IsKey() bool { + return o.isKey.Get() +} + +// SetIsKey sets the value of the isKey property. +func (o *DataEntity) SetIsKey(v bool) { + o.isKey.Set(v) +} + +// ChildMembersItems returns the value of the childMembers property. +func (o *DataEntity) ChildMembersItems() []element.Element { + return o.childMembers.Items() +} + +// AddChildMembers appends a child element to the childMembers list. +func (o *DataEntity) AddChildMembers(v element.Element) { + o.childMembers.Append(v) +} + +// RemoveChildMembers removes the element at the given index from the childMembers list. +func (o *DataEntity) RemoveChildMembers(index int) { + o.childMembers.Remove(index) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *DataEntity) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *DataEntity) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *DataEntity) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *DataEntity) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *DataEntity) InitFromRaw(raw bson.Raw) { + o.isLockedByContract.Init(raw) + o.exposedName.Init(raw) + o.isOptionalByContract.Init(raw) + o.isOptional.Init(raw) + o.isNillableByContract.Init(raw) + o.isNillable.Init(raw) + o.isKey.Init(raw) + if children, err := codec.DecodeChildren(raw, "ChildMembers"); err == nil { + for _, child := range children { + o.childMembers.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + o.exposedItemName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ImportedWebService +// ──────────────────────────────────────────────────────── + +type ImportedWebService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + wsdlDescription *property.Part[element.Element] + wsdlUrl *property.Primitive[string] + useMtom *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *ImportedWebService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ImportedWebService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ImportedWebService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ImportedWebService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *ImportedWebService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *ImportedWebService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *ImportedWebService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *ImportedWebService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// WsdlDescription returns the value of the wsdlDescription property. +func (o *ImportedWebService) WsdlDescription() element.Element { + return o.wsdlDescription.Get() +} + +// SetWsdlDescription sets the value of the wsdlDescription property. +func (o *ImportedWebService) SetWsdlDescription(v element.Element) { + o.wsdlDescription.Set(v) +} + +// WsdlUrl returns the value of the wsdlUrl property. +func (o *ImportedWebService) WsdlUrl() string { + return o.wsdlUrl.Get() +} + +// SetWsdlUrl sets the value of the wsdlUrl property. +func (o *ImportedWebService) SetWsdlUrl(v string) { + o.wsdlUrl.Set(v) +} + +// UseMtom returns the value of the useMtom property. +func (o *ImportedWebService) UseMtom() bool { + return o.useMtom.Get() +} + +// SetUseMtom sets the value of the useMtom property. +func (o *ImportedWebService) SetUseMtom(v bool) { + o.useMtom.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ImportedWebService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "WsdlDescription"); err == nil { + o.wsdlDescription.SetFromDecode(child) + } + o.wsdlUrl.Init(raw) + o.useMtom.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// OperationInfo +// ──────────────────────────────────────────────────────── + +type OperationInfo struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + soapAction *property.Primitive[string] + requestHeaderRpcElement *property.Part[element.Element] + requestBodyRpcElement *property.Part[element.Element] + responseBodyRpcElement *property.Part[element.Element] + requestHeaderElementName *property.Primitive[string] + requestHeaderEncoded *property.Primitive[bool] + requestHeaderPartEncoding *property.Part[element.Element] + requestBodyEncoded *property.Primitive[bool] + requestBodyElementName *property.Primitive[string] + requestBodyPartEncodings *property.PartList[element.Element] + responseBodyElementName *property.Primitive[string] + allowSimpleMappingInheritance *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *OperationInfo) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *OperationInfo) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *OperationInfo) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *OperationInfo) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// SoapAction returns the value of the soapAction property. +func (o *OperationInfo) SoapAction() string { + return o.soapAction.Get() +} + +// SetSoapAction sets the value of the soapAction property. +func (o *OperationInfo) SetSoapAction(v string) { + o.soapAction.Set(v) +} + +// RequestHeaderRpcElement returns the value of the requestHeaderRpcElement property. +func (o *OperationInfo) RequestHeaderRpcElement() element.Element { + return o.requestHeaderRpcElement.Get() +} + +// SetRequestHeaderRpcElement sets the value of the requestHeaderRpcElement property. +func (o *OperationInfo) SetRequestHeaderRpcElement(v element.Element) { + o.requestHeaderRpcElement.Set(v) +} + +// RequestBodyRpcElement returns the value of the requestBodyRpcElement property. +func (o *OperationInfo) RequestBodyRpcElement() element.Element { + return o.requestBodyRpcElement.Get() +} + +// SetRequestBodyRpcElement sets the value of the requestBodyRpcElement property. +func (o *OperationInfo) SetRequestBodyRpcElement(v element.Element) { + o.requestBodyRpcElement.Set(v) +} + +// ResponseBodyRpcElement returns the value of the responseBodyRpcElement property. +func (o *OperationInfo) ResponseBodyRpcElement() element.Element { + return o.responseBodyRpcElement.Get() +} + +// SetResponseBodyRpcElement sets the value of the responseBodyRpcElement property. +func (o *OperationInfo) SetResponseBodyRpcElement(v element.Element) { + o.responseBodyRpcElement.Set(v) +} + +// RequestHeaderElementName returns the value of the requestHeaderElementName property. +func (o *OperationInfo) RequestHeaderElementName() string { + return o.requestHeaderElementName.Get() +} + +// SetRequestHeaderElementName sets the value of the requestHeaderElementName property. +func (o *OperationInfo) SetRequestHeaderElementName(v string) { + o.requestHeaderElementName.Set(v) +} + +// RequestHeaderEncoded returns the value of the requestHeaderEncoded property. +func (o *OperationInfo) RequestHeaderEncoded() bool { + return o.requestHeaderEncoded.Get() +} + +// SetRequestHeaderEncoded sets the value of the requestHeaderEncoded property. +func (o *OperationInfo) SetRequestHeaderEncoded(v bool) { + o.requestHeaderEncoded.Set(v) +} + +// RequestHeaderPartEncoding returns the value of the requestHeaderPartEncoding property. +func (o *OperationInfo) RequestHeaderPartEncoding() element.Element { + return o.requestHeaderPartEncoding.Get() +} + +// SetRequestHeaderPartEncoding sets the value of the requestHeaderPartEncoding property. +func (o *OperationInfo) SetRequestHeaderPartEncoding(v element.Element) { + o.requestHeaderPartEncoding.Set(v) +} + +// RequestBodyEncoded returns the value of the requestBodyEncoded property. +func (o *OperationInfo) RequestBodyEncoded() bool { + return o.requestBodyEncoded.Get() +} + +// SetRequestBodyEncoded sets the value of the requestBodyEncoded property. +func (o *OperationInfo) SetRequestBodyEncoded(v bool) { + o.requestBodyEncoded.Set(v) +} + +// RequestBodyElementName returns the value of the requestBodyElementName property. +func (o *OperationInfo) RequestBodyElementName() string { + return o.requestBodyElementName.Get() +} + +// SetRequestBodyElementName sets the value of the requestBodyElementName property. +func (o *OperationInfo) SetRequestBodyElementName(v string) { + o.requestBodyElementName.Set(v) +} + +// RequestBodyPartEncodingsItems returns the value of the requestBodyPartEncodings property. +func (o *OperationInfo) RequestBodyPartEncodingsItems() []element.Element { + return o.requestBodyPartEncodings.Items() +} + +// AddRequestBodyPartEncodings appends a child element to the requestBodyPartEncodings list. +func (o *OperationInfo) AddRequestBodyPartEncodings(v element.Element) { + o.requestBodyPartEncodings.Append(v) +} + +// RemoveRequestBodyPartEncodings removes the element at the given index from the requestBodyPartEncodings list. +func (o *OperationInfo) RemoveRequestBodyPartEncodings(index int) { + o.requestBodyPartEncodings.Remove(index) +} + +// ResponseBodyElementName returns the value of the responseBodyElementName property. +func (o *OperationInfo) ResponseBodyElementName() string { + return o.responseBodyElementName.Get() +} + +// SetResponseBodyElementName sets the value of the responseBodyElementName property. +func (o *OperationInfo) SetResponseBodyElementName(v string) { + o.responseBodyElementName.Set(v) +} + +// AllowSimpleMappingInheritance returns the value of the allowSimpleMappingInheritance property. +func (o *OperationInfo) AllowSimpleMappingInheritance() bool { + return o.allowSimpleMappingInheritance.Get() +} + +// SetAllowSimpleMappingInheritance sets the value of the allowSimpleMappingInheritance property. +func (o *OperationInfo) SetAllowSimpleMappingInheritance(v bool) { + o.allowSimpleMappingInheritance.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OperationInfo) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.soapAction.Init(raw) + if child, err := codec.DecodeChild(raw, "RequestHeaderRpcElement"); err == nil { + o.requestHeaderRpcElement.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "RequestBodyRpcElement"); err == nil { + o.requestBodyRpcElement.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "ResponseBodyRpcElement"); err == nil { + o.responseBodyRpcElement.SetFromDecode(child) + } + o.requestHeaderElementName.Init(raw) + o.requestHeaderEncoded.Init(raw) + if child, err := codec.DecodeChild(raw, "RequestHeaderPartEncoding"); err == nil { + o.requestHeaderPartEncoding.SetFromDecode(child) + } + o.requestBodyEncoded.Init(raw) + o.requestBodyElementName.Init(raw) + if children, err := codec.DecodeChildren(raw, "RequestBodyPartEncodings"); err == nil { + for _, child := range children { + o.requestBodyPartEncodings.AppendFromDecode(child) + } + } + o.responseBodyElementName.Init(raw) + o.allowSimpleMappingInheritance.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PartEncoding +// ──────────────────────────────────────────────────────── + +type PartEncoding struct { + element.Base + partName *property.Primitive[string] + partXsdType *property.Primitive[string] +} + +// PartName returns the value of the partName property. +func (o *PartEncoding) PartName() string { + return o.partName.Get() +} + +// SetPartName sets the value of the partName property. +func (o *PartEncoding) SetPartName(v string) { + o.partName.Set(v) +} + +// PartXsdType returns the value of the partXsdType property. +func (o *PartEncoding) PartXsdType() string { + return o.partXsdType.Get() +} + +// SetPartXsdType sets the value of the partXsdType property. +func (o *PartEncoding) SetPartXsdType(v string) { + o.partXsdType.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PartEncoding) InitFromRaw(raw bson.Raw) { + o.partName.Init(raw) + o.partXsdType.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedServiceBase +// ──────────────────────────────────────────────────────── + +type PublishedServiceBase struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + versionedServices *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *PublishedServiceBase) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedServiceBase) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedServiceBase) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedServiceBase) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *PublishedServiceBase) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *PublishedServiceBase) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *PublishedServiceBase) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *PublishedServiceBase) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// VersionedServicesItems returns the value of the versionedServices property. +func (o *PublishedServiceBase) VersionedServicesItems() []element.Element { + return o.versionedServices.Items() +} + +// AddVersionedServices appends a child element to the versionedServices list. +func (o *PublishedServiceBase) AddVersionedServices(v element.Element) { + o.versionedServices.Append(v) +} + +// RemoveVersionedServices removes the element at the given index from the versionedServices list. +func (o *PublishedServiceBase) RemoveVersionedServices(index int) { + o.versionedServices.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedServiceBase) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "VersionedServices"); err == nil { + for _, child := range children { + o.versionedServices.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// PublishedAppService +// ──────────────────────────────────────────────────────── + +type PublishedAppService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + versionedServices *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *PublishedAppService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedAppService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedAppService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedAppService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *PublishedAppService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *PublishedAppService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *PublishedAppService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *PublishedAppService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// VersionedServicesItems returns the value of the versionedServices property. +func (o *PublishedAppService) VersionedServicesItems() []element.Element { + return o.versionedServices.Items() +} + +// AddVersionedServices appends a child element to the versionedServices list. +func (o *PublishedAppService) AddVersionedServices(v element.Element) { + o.versionedServices.Append(v) +} + +// RemoveVersionedServices removes the element at the given index from the versionedServices list. +func (o *PublishedAppService) RemoveVersionedServices(index int) { + o.versionedServices.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedAppService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "VersionedServices"); err == nil { + for _, child := range children { + o.versionedServices.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// PublishedResource +// ──────────────────────────────────────────────────────── + +type PublishedResource struct { + element.Base + dataEntity *property.Part[element.Element] +} + +// DataEntity returns the value of the dataEntity property. +func (o *PublishedResource) DataEntity() element.Element { + return o.dataEntity.Get() +} + +// SetDataEntity sets the value of the dataEntity property. +func (o *PublishedResource) SetDataEntity(v element.Element) { + o.dataEntity.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedResource) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "DataEntity"); err == nil { + o.dataEntity.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// PublishedOperation +// ──────────────────────────────────────────────────────── + +type PublishedOperation struct { + element.Base + dataEntity *property.Part[element.Element] + isLockedByContract *property.Primitive[bool] + name *property.Primitive[string] + image *property.ByNameRef[element.Element] + description *property.Primitive[string] + documentation *property.Primitive[string] + microflow *property.ByNameRef[element.Element] + parameters *property.PartList[element.Element] + returnTypeNameByContract *property.Primitive[string] + returnTypeSpecificationByContract *property.Primitive[string] + entityExposedNameByContract *property.Primitive[string] + entityExposedName *property.Primitive[string] + returnType *property.Primitive[string] + operationReturnType *property.Part[element.Element] + returnTypeIsOptional *property.Primitive[bool] + returnTypeIsNillable *property.Primitive[bool] +} + +// DataEntity returns the value of the dataEntity property. +func (o *PublishedOperation) DataEntity() element.Element { + return o.dataEntity.Get() +} + +// SetDataEntity sets the value of the dataEntity property. +func (o *PublishedOperation) SetDataEntity(v element.Element) { + o.dataEntity.Set(v) +} + +// IsLockedByContract returns the value of the isLockedByContract property. +func (o *PublishedOperation) IsLockedByContract() bool { + return o.isLockedByContract.Get() +} + +// SetIsLockedByContract sets the value of the isLockedByContract property. +func (o *PublishedOperation) SetIsLockedByContract(v bool) { + o.isLockedByContract.Set(v) +} + +// Name returns the value of the name property. +func (o *PublishedOperation) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedOperation) SetName(v string) { + o.name.Set(v) +} + +// ImageQualifiedName returns the value of the image property. +func (o *PublishedOperation) ImageQualifiedName() string { + return o.image.QualifiedName() +} + +// SetImageQualifiedName sets the value of the image property. +func (o *PublishedOperation) SetImageQualifiedName(v string) { + o.image.SetQualifiedName(v) +} + +// Description returns the value of the description property. +func (o *PublishedOperation) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *PublishedOperation) SetDescription(v string) { + o.description.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedOperation) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedOperation) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *PublishedOperation) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *PublishedOperation) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ParametersItems returns the value of the parameters property. +func (o *PublishedOperation) ParametersItems() []element.Element { + return o.parameters.Items() +} + +// AddParameters appends a child element to the parameters list. +func (o *PublishedOperation) AddParameters(v element.Element) { + o.parameters.Append(v) +} + +// RemoveParameters removes the element at the given index from the parameters list. +func (o *PublishedOperation) RemoveParameters(index int) { + o.parameters.Remove(index) +} + +// ReturnTypeNameByContract returns the value of the returnTypeNameByContract property. +func (o *PublishedOperation) ReturnTypeNameByContract() string { + return o.returnTypeNameByContract.Get() +} + +// SetReturnTypeNameByContract sets the value of the returnTypeNameByContract property. +func (o *PublishedOperation) SetReturnTypeNameByContract(v string) { + o.returnTypeNameByContract.Set(v) +} + +// ReturnTypeSpecificationByContract returns the value of the returnTypeSpecificationByContract property. +func (o *PublishedOperation) ReturnTypeSpecificationByContract() string { + return o.returnTypeSpecificationByContract.Get() +} + +// SetReturnTypeSpecificationByContract sets the value of the returnTypeSpecificationByContract property. +func (o *PublishedOperation) SetReturnTypeSpecificationByContract(v string) { + o.returnTypeSpecificationByContract.Set(v) +} + +// EntityExposedNameByContract returns the value of the entityExposedNameByContract property. +func (o *PublishedOperation) EntityExposedNameByContract() string { + return o.entityExposedNameByContract.Get() +} + +// SetEntityExposedNameByContract sets the value of the entityExposedNameByContract property. +func (o *PublishedOperation) SetEntityExposedNameByContract(v string) { + o.entityExposedNameByContract.Set(v) +} + +// EntityExposedName returns the value of the entityExposedName property. +func (o *PublishedOperation) EntityExposedName() string { + return o.entityExposedName.Get() +} + +// SetEntityExposedName sets the value of the entityExposedName property. +func (o *PublishedOperation) SetEntityExposedName(v string) { + o.entityExposedName.Set(v) +} + +// ReturnType returns the value of the returnType property. +func (o *PublishedOperation) ReturnType() string { + return o.returnType.Get() +} + +// SetReturnType sets the value of the returnType property. +func (o *PublishedOperation) SetReturnType(v string) { + o.returnType.Set(v) +} + +// OperationReturnType returns the value of the operationReturnType property. +func (o *PublishedOperation) OperationReturnType() element.Element { + return o.operationReturnType.Get() +} + +// SetOperationReturnType sets the value of the operationReturnType property. +func (o *PublishedOperation) SetOperationReturnType(v element.Element) { + o.operationReturnType.Set(v) +} + +// ReturnTypeIsOptional returns the value of the returnTypeIsOptional property. +func (o *PublishedOperation) ReturnTypeIsOptional() bool { + return o.returnTypeIsOptional.Get() +} + +// SetReturnTypeIsOptional sets the value of the returnTypeIsOptional property. +func (o *PublishedOperation) SetReturnTypeIsOptional(v bool) { + o.returnTypeIsOptional.Set(v) +} + +// ReturnTypeIsNillable returns the value of the returnTypeIsNillable property. +func (o *PublishedOperation) ReturnTypeIsNillable() bool { + return o.returnTypeIsNillable.Get() +} + +// SetReturnTypeIsNillable sets the value of the returnTypeIsNillable property. +func (o *PublishedOperation) SetReturnTypeIsNillable(v bool) { + o.returnTypeIsNillable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedOperation) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "DataEntity"); err == nil { + o.dataEntity.SetFromDecode(child) + } + o.isLockedByContract.Init(raw) + o.name.Init(raw) + if val, err := raw.LookupErr("Image"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.image.SetFromDecode(s) + } + } + o.description.Init(raw) + o.documentation.Init(raw) + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.microflow.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Parameters"); err == nil { + for _, child := range children { + o.parameters.AppendFromDecode(child) + } + } + o.returnTypeNameByContract.Init(raw) + o.returnTypeSpecificationByContract.Init(raw) + o.entityExposedNameByContract.Init(raw) + o.entityExposedName.Init(raw) + o.returnType.Init(raw) + if child, err := codec.DecodeChild(raw, "OperationReturnType"); err == nil { + o.operationReturnType.SetFromDecode(child) + } + o.returnTypeIsOptional.Init(raw) + o.returnTypeIsNillable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PublishedParameter +// ──────────────────────────────────────────────────────── + +type PublishedParameter struct { + element.Base + isLockedByContract *property.Primitive[bool] + parameter *property.ByNameRef[element.Element] + parameterByContract *property.Part[element.Element] + entityExposedName *property.Primitive[string] + isOptionalByContract *property.Primitive[bool] + isOptional *property.Primitive[bool] + isNillable *property.Primitive[bool] + entityExposedItemNameByContract *property.Primitive[string] + entityExposedItemName *property.Primitive[string] + propType *property.Primitive[string] + parameterType *property.Part[element.Element] + dataEntity *property.Part[element.Element] +} + +// IsLockedByContract returns the value of the isLockedByContract property. +func (o *PublishedParameter) IsLockedByContract() bool { + return o.isLockedByContract.Get() +} + +// SetIsLockedByContract sets the value of the isLockedByContract property. +func (o *PublishedParameter) SetIsLockedByContract(v bool) { + o.isLockedByContract.Set(v) +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *PublishedParameter) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *PublishedParameter) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// ParameterByContract returns the value of the parameterByContract property. +func (o *PublishedParameter) ParameterByContract() element.Element { + return o.parameterByContract.Get() +} + +// SetParameterByContract sets the value of the parameterByContract property. +func (o *PublishedParameter) SetParameterByContract(v element.Element) { + o.parameterByContract.Set(v) +} + +// EntityExposedName returns the value of the entityExposedName property. +func (o *PublishedParameter) EntityExposedName() string { + return o.entityExposedName.Get() +} + +// SetEntityExposedName sets the value of the entityExposedName property. +func (o *PublishedParameter) SetEntityExposedName(v string) { + o.entityExposedName.Set(v) +} + +// IsOptionalByContract returns the value of the isOptionalByContract property. +func (o *PublishedParameter) IsOptionalByContract() bool { + return o.isOptionalByContract.Get() +} + +// SetIsOptionalByContract sets the value of the isOptionalByContract property. +func (o *PublishedParameter) SetIsOptionalByContract(v bool) { + o.isOptionalByContract.Set(v) +} + +// IsOptional returns the value of the isOptional property. +func (o *PublishedParameter) IsOptional() bool { + return o.isOptional.Get() +} + +// SetIsOptional sets the value of the isOptional property. +func (o *PublishedParameter) SetIsOptional(v bool) { + o.isOptional.Set(v) +} + +// IsNillable returns the value of the isNillable property. +func (o *PublishedParameter) IsNillable() bool { + return o.isNillable.Get() +} + +// SetIsNillable sets the value of the isNillable property. +func (o *PublishedParameter) SetIsNillable(v bool) { + o.isNillable.Set(v) +} + +// EntityExposedItemNameByContract returns the value of the entityExposedItemNameByContract property. +func (o *PublishedParameter) EntityExposedItemNameByContract() string { + return o.entityExposedItemNameByContract.Get() +} + +// SetEntityExposedItemNameByContract sets the value of the entityExposedItemNameByContract property. +func (o *PublishedParameter) SetEntityExposedItemNameByContract(v string) { + o.entityExposedItemNameByContract.Set(v) +} + +// EntityExposedItemName returns the value of the entityExposedItemName property. +func (o *PublishedParameter) EntityExposedItemName() string { + return o.entityExposedItemName.Get() +} + +// SetEntityExposedItemName sets the value of the entityExposedItemName property. +func (o *PublishedParameter) SetEntityExposedItemName(v string) { + o.entityExposedItemName.Set(v) +} + +// Type returns the value of the type property. +func (o *PublishedParameter) Type() string { + return o.propType.Get() +} + +// SetType sets the value of the type property. +func (o *PublishedParameter) SetType(v string) { + o.propType.Set(v) +} + +// ParameterType returns the value of the parameterType property. +func (o *PublishedParameter) ParameterType() element.Element { + return o.parameterType.Get() +} + +// SetParameterType sets the value of the parameterType property. +func (o *PublishedParameter) SetParameterType(v element.Element) { + o.parameterType.Set(v) +} + +// DataEntity returns the value of the dataEntity property. +func (o *PublishedParameter) DataEntity() element.Element { + return o.dataEntity.Get() +} + +// SetDataEntity sets the value of the dataEntity property. +func (o *PublishedParameter) SetDataEntity(v element.Element) { + o.dataEntity.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedParameter) InitFromRaw(raw bson.Raw) { + o.isLockedByContract.Init(raw) + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.parameter.SetFromDecode(s) + } + } + if child, err := codec.DecodeChild(raw, "ParameterByContract"); err == nil { + o.parameterByContract.SetFromDecode(child) + } + o.entityExposedName.Init(raw) + o.isOptionalByContract.Init(raw) + o.isOptional.Init(raw) + o.isNillable.Init(raw) + o.entityExposedItemNameByContract.Init(raw) + o.entityExposedItemName.Init(raw) + o.propType.Init(raw) + if child, err := codec.DecodeChild(raw, "ParameterType"); err == nil { + o.parameterType.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "DataEntity"); err == nil { + o.dataEntity.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// PublishedWebService +// ──────────────────────────────────────────────────────── + +type PublishedWebService struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + versionedServices *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *PublishedWebService) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *PublishedWebService) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *PublishedWebService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *PublishedWebService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *PublishedWebService) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *PublishedWebService) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *PublishedWebService) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *PublishedWebService) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// VersionedServicesItems returns the value of the versionedServices property. +func (o *PublishedWebService) VersionedServicesItems() []element.Element { + return o.versionedServices.Items() +} + +// AddVersionedServices appends a child element to the versionedServices list. +func (o *PublishedWebService) AddVersionedServices(v element.Element) { + o.versionedServices.Append(v) +} + +// RemoveVersionedServices removes the element at the given index from the versionedServices list. +func (o *PublishedWebService) RemoveVersionedServices(index int) { + o.versionedServices.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PublishedWebService) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "VersionedServices"); err == nil { + for _, child := range children { + o.versionedServices.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// RpcMessagePartElement +// ──────────────────────────────────────────────────────── + +type RpcMessagePartElement struct { + element.Base + partName *property.Primitive[string] + propTypeName *property.Primitive[string] + elementName *property.Primitive[string] +} + +// PartName returns the value of the partName property. +func (o *RpcMessagePartElement) PartName() string { + return o.partName.Get() +} + +// SetPartName sets the value of the partName property. +func (o *RpcMessagePartElement) SetPartName(v string) { + o.partName.Set(v) +} + +// TypeName returns the value of the typeName property. +func (o *RpcMessagePartElement) TypeName() string { + return o.propTypeName.Get() +} + +// SetTypeName sets the value of the typeName property. +func (o *RpcMessagePartElement) SetTypeName(v string) { + o.propTypeName.Set(v) +} + +// ElementName returns the value of the elementName property. +func (o *RpcMessagePartElement) ElementName() string { + return o.elementName.Get() +} + +// SetElementName sets the value of the elementName property. +func (o *RpcMessagePartElement) SetElementName(v string) { + o.elementName.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RpcMessagePartElement) InitFromRaw(raw bson.Raw) { + o.partName.Init(raw) + o.propTypeName.Init(raw) + o.elementName.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// RpcOperationElement +// ──────────────────────────────────────────────────────── + +type RpcOperationElement struct { + element.Base + name *property.Primitive[string] + messagePartElements *property.PartList[element.Element] +} + +// Name returns the value of the name property. +func (o *RpcOperationElement) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *RpcOperationElement) SetName(v string) { + o.name.Set(v) +} + +// MessagePartElementsItems returns the value of the messagePartElements property. +func (o *RpcOperationElement) MessagePartElementsItems() []element.Element { + return o.messagePartElements.Items() +} + +// AddMessagePartElements appends a child element to the messagePartElements list. +func (o *RpcOperationElement) AddMessagePartElements(v element.Element) { + o.messagePartElements.Append(v) +} + +// RemoveMessagePartElements removes the element at the given index from the messagePartElements list. +func (o *RpcOperationElement) RemoveMessagePartElements(index int) { + o.messagePartElements.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *RpcOperationElement) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + if children, err := codec.DecodeChildren(raw, "MessagePartElements"); err == nil { + for _, child := range children { + o.messagePartElements.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ServiceInfo +// ──────────────────────────────────────────────────────── + +type ServiceInfo struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + portName *property.Primitive[string] + location *property.Primitive[string] + soapVersion *property.Enum[string] + locationConstant *property.ByNameRef[element.Element] + operations *property.PartList[element.Element] + usingAddressing *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *ServiceInfo) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ServiceInfo) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *ServiceInfo) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *ServiceInfo) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// PortName returns the value of the portName property. +func (o *ServiceInfo) PortName() string { + return o.portName.Get() +} + +// SetPortName sets the value of the portName property. +func (o *ServiceInfo) SetPortName(v string) { + o.portName.Set(v) +} + +// Location returns the value of the location property. +func (o *ServiceInfo) Location() string { + return o.location.Get() +} + +// SetLocation sets the value of the location property. +func (o *ServiceInfo) SetLocation(v string) { + o.location.Set(v) +} + +// SoapVersion returns the value of the soapVersion property. +func (o *ServiceInfo) SoapVersion() string { + return o.soapVersion.Get() +} + +// SetSoapVersion sets the value of the soapVersion property. +func (o *ServiceInfo) SetSoapVersion(v string) { + o.soapVersion.Set(v) +} + +// LocationConstantQualifiedName returns the value of the locationConstant property. +func (o *ServiceInfo) LocationConstantQualifiedName() string { + return o.locationConstant.QualifiedName() +} + +// SetLocationConstantQualifiedName sets the value of the locationConstant property. +func (o *ServiceInfo) SetLocationConstantQualifiedName(v string) { + o.locationConstant.SetQualifiedName(v) +} + +// OperationsItems returns the value of the operations property. +func (o *ServiceInfo) OperationsItems() []element.Element { + return o.operations.Items() +} + +// AddOperations appends a child element to the operations list. +func (o *ServiceInfo) AddOperations(v element.Element) { + o.operations.Append(v) +} + +// RemoveOperations removes the element at the given index from the operations list. +func (o *ServiceInfo) RemoveOperations(index int) { + o.operations.Remove(index) +} + +// UsingAddressing returns the value of the usingAddressing property. +func (o *ServiceInfo) UsingAddressing() bool { + return o.usingAddressing.Get() +} + +// SetUsingAddressing sets the value of the usingAddressing property. +func (o *ServiceInfo) SetUsingAddressing(v bool) { + o.usingAddressing.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ServiceInfo) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.portName.Init(raw) + o.location.Init(raw) + if val, err := raw.LookupErr("SoapVersion"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.soapVersion.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("LocationConstant"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.locationConstant.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Operations"); err == nil { + for _, child := range children { + o.operations.AppendFromDecode(child) + } + } + o.usingAddressing.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SystemIdDataAttribute +// ──────────────────────────────────────────────────────── + +type SystemIdDataAttribute struct { + element.Base + isLockedByContract *property.Primitive[bool] + exposedName *property.Primitive[string] + isOptionalByContract *property.Primitive[bool] + isOptional *property.Primitive[bool] + isNillableByContract *property.Primitive[bool] + isNillable *property.Primitive[bool] + isKey *property.Primitive[bool] + entity *property.ByNameRef[element.Element] + summary *property.Primitive[string] + description *property.Primitive[string] +} + +// IsLockedByContract returns the value of the isLockedByContract property. +func (o *SystemIdDataAttribute) IsLockedByContract() bool { + return o.isLockedByContract.Get() +} + +// SetIsLockedByContract sets the value of the isLockedByContract property. +func (o *SystemIdDataAttribute) SetIsLockedByContract(v bool) { + o.isLockedByContract.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *SystemIdDataAttribute) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *SystemIdDataAttribute) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// IsOptionalByContract returns the value of the isOptionalByContract property. +func (o *SystemIdDataAttribute) IsOptionalByContract() bool { + return o.isOptionalByContract.Get() +} + +// SetIsOptionalByContract sets the value of the isOptionalByContract property. +func (o *SystemIdDataAttribute) SetIsOptionalByContract(v bool) { + o.isOptionalByContract.Set(v) +} + +// IsOptional returns the value of the isOptional property. +func (o *SystemIdDataAttribute) IsOptional() bool { + return o.isOptional.Get() +} + +// SetIsOptional sets the value of the isOptional property. +func (o *SystemIdDataAttribute) SetIsOptional(v bool) { + o.isOptional.Set(v) +} + +// IsNillableByContract returns the value of the isNillableByContract property. +func (o *SystemIdDataAttribute) IsNillableByContract() bool { + return o.isNillableByContract.Get() +} + +// SetIsNillableByContract sets the value of the isNillableByContract property. +func (o *SystemIdDataAttribute) SetIsNillableByContract(v bool) { + o.isNillableByContract.Set(v) +} + +// IsNillable returns the value of the isNillable property. +func (o *SystemIdDataAttribute) IsNillable() bool { + return o.isNillable.Get() +} + +// SetIsNillable sets the value of the isNillable property. +func (o *SystemIdDataAttribute) SetIsNillable(v bool) { + o.isNillable.Set(v) +} + +// IsKey returns the value of the isKey property. +func (o *SystemIdDataAttribute) IsKey() bool { + return o.isKey.Get() +} + +// SetIsKey sets the value of the isKey property. +func (o *SystemIdDataAttribute) SetIsKey(v bool) { + o.isKey.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *SystemIdDataAttribute) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *SystemIdDataAttribute) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// Summary returns the value of the summary property. +func (o *SystemIdDataAttribute) Summary() string { + return o.summary.Get() +} + +// SetSummary sets the value of the summary property. +func (o *SystemIdDataAttribute) SetSummary(v string) { + o.summary.Set(v) +} + +// Description returns the value of the description property. +func (o *SystemIdDataAttribute) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *SystemIdDataAttribute) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SystemIdDataAttribute) InitFromRaw(raw bson.Raw) { + o.isLockedByContract.Init(raw) + o.exposedName.Init(raw) + o.isOptionalByContract.Init(raw) + o.isOptional.Init(raw) + o.isNillableByContract.Init(raw) + o.isNillable.Init(raw) + o.isKey.Init(raw) + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.entity.SetFromDecode(s) + } + } + o.summary.Init(raw) + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// VersionedService +// ──────────────────────────────────────────────────────── + +type VersionedService struct { + element.Base + documentation *property.Primitive[string] + targetNamespace *property.Primitive[string] + headerAuthentication *property.Enum[string] + operations *property.PartList[element.Element] + isLockedByContract *property.Primitive[bool] + enumerationsByContract *property.Part[element.Element] + optimizedXml *property.Primitive[bool] + headerImportMapping *property.ByNameRef[element.Element] + objectHandlingBackup *property.Enum[string] + headerMicroflow *property.ByNameRef[element.Element] + versionNumber *property.Primitive[int32] + caption *property.Primitive[string] + description *property.Primitive[string] + appServiceState *property.Enum[string] + image *property.ByNameRef[element.Element] + validate *property.Primitive[bool] +} + +// Documentation returns the value of the documentation property. +func (o *VersionedService) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *VersionedService) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// TargetNamespace returns the value of the targetNamespace property. +func (o *VersionedService) TargetNamespace() string { + return o.targetNamespace.Get() +} + +// SetTargetNamespace sets the value of the targetNamespace property. +func (o *VersionedService) SetTargetNamespace(v string) { + o.targetNamespace.Set(v) +} + +// HeaderAuthentication returns the value of the headerAuthentication property. +func (o *VersionedService) HeaderAuthentication() string { + return o.headerAuthentication.Get() +} + +// SetHeaderAuthentication sets the value of the headerAuthentication property. +func (o *VersionedService) SetHeaderAuthentication(v string) { + o.headerAuthentication.Set(v) +} + +// OperationsItems returns the value of the operations property. +func (o *VersionedService) OperationsItems() []element.Element { + return o.operations.Items() +} + +// AddOperations appends a child element to the operations list. +func (o *VersionedService) AddOperations(v element.Element) { + o.operations.Append(v) +} + +// RemoveOperations removes the element at the given index from the operations list. +func (o *VersionedService) RemoveOperations(index int) { + o.operations.Remove(index) +} + +// IsLockedByContract returns the value of the isLockedByContract property. +func (o *VersionedService) IsLockedByContract() bool { + return o.isLockedByContract.Get() +} + +// SetIsLockedByContract sets the value of the isLockedByContract property. +func (o *VersionedService) SetIsLockedByContract(v bool) { + o.isLockedByContract.Set(v) +} + +// EnumerationsByContract returns the value of the enumerationsByContract property. +func (o *VersionedService) EnumerationsByContract() element.Element { + return o.enumerationsByContract.Get() +} + +// SetEnumerationsByContract sets the value of the enumerationsByContract property. +func (o *VersionedService) SetEnumerationsByContract(v element.Element) { + o.enumerationsByContract.Set(v) +} + +// OptimizedXml returns the value of the optimizedXml property. +func (o *VersionedService) OptimizedXml() bool { + return o.optimizedXml.Get() +} + +// SetOptimizedXml sets the value of the optimizedXml property. +func (o *VersionedService) SetOptimizedXml(v bool) { + o.optimizedXml.Set(v) +} + +// HeaderImportMappingQualifiedName returns the value of the headerImportMapping property. +func (o *VersionedService) HeaderImportMappingQualifiedName() string { + return o.headerImportMapping.QualifiedName() +} + +// SetHeaderImportMappingQualifiedName sets the value of the headerImportMapping property. +func (o *VersionedService) SetHeaderImportMappingQualifiedName(v string) { + o.headerImportMapping.SetQualifiedName(v) +} + +// ObjectHandlingBackup returns the value of the objectHandlingBackup property. +func (o *VersionedService) ObjectHandlingBackup() string { + return o.objectHandlingBackup.Get() +} + +// SetObjectHandlingBackup sets the value of the objectHandlingBackup property. +func (o *VersionedService) SetObjectHandlingBackup(v string) { + o.objectHandlingBackup.Set(v) +} + +// HeaderMicroflowQualifiedName returns the value of the headerMicroflow property. +func (o *VersionedService) HeaderMicroflowQualifiedName() string { + return o.headerMicroflow.QualifiedName() +} + +// SetHeaderMicroflowQualifiedName sets the value of the headerMicroflow property. +func (o *VersionedService) SetHeaderMicroflowQualifiedName(v string) { + o.headerMicroflow.SetQualifiedName(v) +} + +// VersionNumber returns the value of the versionNumber property. +func (o *VersionedService) VersionNumber() int32 { + return o.versionNumber.Get() +} + +// SetVersionNumber sets the value of the versionNumber property. +func (o *VersionedService) SetVersionNumber(v int32) { + o.versionNumber.Set(v) +} + +// Caption returns the value of the caption property. +func (o *VersionedService) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *VersionedService) SetCaption(v string) { + o.caption.Set(v) +} + +// Description returns the value of the description property. +func (o *VersionedService) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *VersionedService) SetDescription(v string) { + o.description.Set(v) +} + +// AppServiceState returns the value of the appServiceState property. +func (o *VersionedService) AppServiceState() string { + return o.appServiceState.Get() +} + +// SetAppServiceState sets the value of the appServiceState property. +func (o *VersionedService) SetAppServiceState(v string) { + o.appServiceState.Set(v) +} + +// ImageQualifiedName returns the value of the image property. +func (o *VersionedService) ImageQualifiedName() string { + return o.image.QualifiedName() +} + +// SetImageQualifiedName sets the value of the image property. +func (o *VersionedService) SetImageQualifiedName(v string) { + o.image.SetQualifiedName(v) +} + +// Validate returns the value of the validate property. +func (o *VersionedService) Validate() bool { + return o.validate.Get() +} + +// SetValidate sets the value of the validate property. +func (o *VersionedService) SetValidate(v bool) { + o.validate.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VersionedService) InitFromRaw(raw bson.Raw) { + o.documentation.Init(raw) + o.targetNamespace.Init(raw) + if val, err := raw.LookupErr("HeaderAuthentication"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.headerAuthentication.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Operations"); err == nil { + for _, child := range children { + o.operations.AppendFromDecode(child) + } + } + o.isLockedByContract.Init(raw) + if child, err := codec.DecodeChild(raw, "EnumerationsByContract"); err == nil { + o.enumerationsByContract.SetFromDecode(child) + } + o.optimizedXml.Init(raw) + if val, err := raw.LookupErr("HeaderImportMapping"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.headerImportMapping.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("ObjectHandlingBackup"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.objectHandlingBackup.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("HeaderMicroflow"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.headerMicroflow.SetFromDecode(s) + } + } + o.versionNumber.Init(raw) + o.caption.Init(raw) + o.description.Init(raw) + if val, err := raw.LookupErr("AppServiceState"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.appServiceState.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("Image"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.image.SetFromDecode(s) + } + } + o.validate.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WsdlDescription +// ──────────────────────────────────────────────────────── + +type WsdlDescription struct { + element.Base + wsdlEntries *property.PartList[element.Element] + schemaEntries *property.PartList[element.Element] + services *property.PartList[element.Element] + targetNamespace *property.Primitive[string] + importsHaveLocations *property.Primitive[bool] +} + +// WsdlEntriesItems returns the value of the wsdlEntries property. +func (o *WsdlDescription) WsdlEntriesItems() []element.Element { + return o.wsdlEntries.Items() +} + +// AddWsdlEntries appends a child element to the wsdlEntries list. +func (o *WsdlDescription) AddWsdlEntries(v element.Element) { + o.wsdlEntries.Append(v) +} + +// RemoveWsdlEntries removes the element at the given index from the wsdlEntries list. +func (o *WsdlDescription) RemoveWsdlEntries(index int) { + o.wsdlEntries.Remove(index) +} + +// SchemaEntriesItems returns the value of the schemaEntries property. +func (o *WsdlDescription) SchemaEntriesItems() []element.Element { + return o.schemaEntries.Items() +} + +// AddSchemaEntries appends a child element to the schemaEntries list. +func (o *WsdlDescription) AddSchemaEntries(v element.Element) { + o.schemaEntries.Append(v) +} + +// RemoveSchemaEntries removes the element at the given index from the schemaEntries list. +func (o *WsdlDescription) RemoveSchemaEntries(index int) { + o.schemaEntries.Remove(index) +} + +// ServicesItems returns the value of the services property. +func (o *WsdlDescription) ServicesItems() []element.Element { + return o.services.Items() +} + +// AddServices appends a child element to the services list. +func (o *WsdlDescription) AddServices(v element.Element) { + o.services.Append(v) +} + +// RemoveServices removes the element at the given index from the services list. +func (o *WsdlDescription) RemoveServices(index int) { + o.services.Remove(index) +} + +// TargetNamespace returns the value of the targetNamespace property. +func (o *WsdlDescription) TargetNamespace() string { + return o.targetNamespace.Get() +} + +// SetTargetNamespace sets the value of the targetNamespace property. +func (o *WsdlDescription) SetTargetNamespace(v string) { + o.targetNamespace.Set(v) +} + +// ImportsHaveLocations returns the value of the importsHaveLocations property. +func (o *WsdlDescription) ImportsHaveLocations() bool { + return o.importsHaveLocations.Get() +} + +// SetImportsHaveLocations sets the value of the importsHaveLocations property. +func (o *WsdlDescription) SetImportsHaveLocations(v bool) { + o.importsHaveLocations.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WsdlDescription) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "WsdlEntries"); err == nil { + for _, child := range children { + o.wsdlEntries.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "SchemaEntries"); err == nil { + for _, child := range children { + o.schemaEntries.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Services"); err == nil { + for _, child := range children { + o.services.AppendFromDecode(child) + } + } + o.targetNamespace.Init(raw) + o.importsHaveLocations.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WsdlEntry +// ──────────────────────────────────────────────────────── + +type WsdlEntry struct { + element.Base + location *property.Primitive[string] + contents *property.Primitive[string] + localizedLocationFormat *property.Primitive[string] + localizedContentsFormat *property.Primitive[string] +} + +// Location returns the value of the location property. +func (o *WsdlEntry) Location() string { + return o.location.Get() +} + +// SetLocation sets the value of the location property. +func (o *WsdlEntry) SetLocation(v string) { + o.location.Set(v) +} + +// Contents returns the value of the contents property. +func (o *WsdlEntry) Contents() string { + return o.contents.Get() +} + +// SetContents sets the value of the contents property. +func (o *WsdlEntry) SetContents(v string) { + o.contents.Set(v) +} + +// LocalizedLocationFormat returns the value of the localizedLocationFormat property. +func (o *WsdlEntry) LocalizedLocationFormat() string { + return o.localizedLocationFormat.Get() +} + +// SetLocalizedLocationFormat sets the value of the localizedLocationFormat property. +func (o *WsdlEntry) SetLocalizedLocationFormat(v string) { + o.localizedLocationFormat.Set(v) +} + +// LocalizedContentsFormat returns the value of the localizedContentsFormat property. +func (o *WsdlEntry) LocalizedContentsFormat() string { + return o.localizedContentsFormat.Get() +} + +// SetLocalizedContentsFormat sets the value of the localizedContentsFormat property. +func (o *WsdlEntry) SetLocalizedContentsFormat(v string) { + o.localizedContentsFormat.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WsdlEntry) InitFromRaw(raw bson.Raw) { + o.location.Init(raw) + o.contents.Init(raw) + o.localizedLocationFormat.Init(raw) + o.localizedContentsFormat.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initDataAssociation creates a DataAssociation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataAssociation() *DataAssociation { + o := &DataAssociation{} + o.SetTypeName("WebServices$DataAssociationImpl") + o.isLockedByContract = property.NewPrimitive[bool]("IsLockedByContract", property.DecodeBool) + o.isLockedByContract.Bind(&o.Base, 0) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 1) + o.isOptionalByContract = property.NewPrimitive[bool]("IsOptionalByContract", property.DecodeBool) + o.isOptionalByContract.Bind(&o.Base, 2) + o.isOptional = property.NewPrimitive[bool]("IsOptional", property.DecodeBool) + o.isOptional.Bind(&o.Base, 3) + o.isNillableByContract = property.NewPrimitive[bool]("IsNillableByContract", property.DecodeBool) + o.isNillableByContract.Bind(&o.Base, 4) + o.isNillable = property.NewPrimitive[bool]("IsNillable", property.DecodeBool) + o.isNillable.Bind(&o.Base, 5) + o.isKey = property.NewPrimitive[bool]("IsKey", property.DecodeBool) + o.isKey.Bind(&o.Base, 6) + o.childMembers = property.NewPartList[element.Element]("ChildMembers") + o.childMembers.Bind(&o.Base, 7) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 8) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 9) + o.associationByContract = property.NewPart[element.Element]("AssociationByContract") + o.associationByContract.Bind(&o.Base, 10) + o.association = property.NewByNameRef[element.Element]("Association", "DomainModels$AssociationBase") + o.association.Bind(&o.Base, 11) + o.exposedAssociationName = property.NewPrimitive[string]("ExposedAssociationName", property.DecodeString) + o.exposedAssociationName.Bind(&o.Base, 12) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 13) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.isLockedByContract, o.exposedName, o.isOptionalByContract, o.isOptional, o.isNillableByContract, o.isNillable, o.isKey, o.childMembers, o.entity, o.exposedItemName, o.associationByContract, o.association, o.exposedAssociationName, o.summary, o.description}) + return o +} + +// NewDataAssociation creates a new DataAssociation for user code. Marked dirty (bit 63 = new element). +func NewDataAssociation() *DataAssociation { + o := initDataAssociation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataAttribute creates a DataAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataAttribute() *DataAttribute { + o := &DataAttribute{} + o.SetTypeName("WebServices$DataAttributeImpl") + o.isLockedByContract = property.NewPrimitive[bool]("IsLockedByContract", property.DecodeBool) + o.isLockedByContract.Bind(&o.Base, 0) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 1) + o.isOptionalByContract = property.NewPrimitive[bool]("IsOptionalByContract", property.DecodeBool) + o.isOptionalByContract.Bind(&o.Base, 2) + o.isOptional = property.NewPrimitive[bool]("IsOptional", property.DecodeBool) + o.isOptional.Bind(&o.Base, 3) + o.isNillableByContract = property.NewPrimitive[bool]("IsNillableByContract", property.DecodeBool) + o.isNillableByContract.Bind(&o.Base, 4) + o.isNillable = property.NewPrimitive[bool]("IsNillable", property.DecodeBool) + o.isNillable.Bind(&o.Base, 5) + o.isKey = property.NewPrimitive[bool]("IsKey", property.DecodeBool) + o.isKey.Bind(&o.Base, 6) + o.attributeByContract = property.NewPart[element.Element]("AttributeByContract") + o.attributeByContract.Bind(&o.Base, 7) + o.attribute = property.NewByNameRef[element.Element]("Attribute", "DomainModels$Attribute") + o.attribute.Bind(&o.Base, 8) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 9) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 10) + o.filterable = property.NewPrimitive[bool]("Filterable", property.DecodeBool) + o.filterable.Bind(&o.Base, 11) + o.sortable = property.NewPrimitive[bool]("Sortable", property.DecodeBool) + o.sortable.Bind(&o.Base, 12) + o.enumerationAsString = property.NewPrimitive[bool]("EnumerationAsString", property.DecodeBool) + o.enumerationAsString.Bind(&o.Base, 13) + o.SetProperties([]element.Property{o.isLockedByContract, o.exposedName, o.isOptionalByContract, o.isOptional, o.isNillableByContract, o.isNillable, o.isKey, o.attributeByContract, o.attribute, o.summary, o.description, o.filterable, o.sortable, o.enumerationAsString}) + return o +} + +// NewDataAttribute creates a new DataAttribute for user code. Marked dirty (bit 63 = new element). +func NewDataAttribute() *DataAttribute { + o := initDataAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initDataEntity creates a DataEntity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initDataEntity() *DataEntity { + o := &DataEntity{} + o.SetTypeName("WebServices$DataEntityImpl") + o.isLockedByContract = property.NewPrimitive[bool]("IsLockedByContract", property.DecodeBool) + o.isLockedByContract.Bind(&o.Base, 0) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 1) + o.isOptionalByContract = property.NewPrimitive[bool]("IsOptionalByContract", property.DecodeBool) + o.isOptionalByContract.Bind(&o.Base, 2) + o.isOptional = property.NewPrimitive[bool]("IsOptional", property.DecodeBool) + o.isOptional.Bind(&o.Base, 3) + o.isNillableByContract = property.NewPrimitive[bool]("IsNillableByContract", property.DecodeBool) + o.isNillableByContract.Bind(&o.Base, 4) + o.isNillable = property.NewPrimitive[bool]("IsNillable", property.DecodeBool) + o.isNillable.Bind(&o.Base, 5) + o.isKey = property.NewPrimitive[bool]("IsKey", property.DecodeBool) + o.isKey.Bind(&o.Base, 6) + o.childMembers = property.NewPartList[element.Element]("ChildMembers") + o.childMembers.Bind(&o.Base, 7) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 8) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.isLockedByContract, o.exposedName, o.isOptionalByContract, o.isOptional, o.isNillableByContract, o.isNillable, o.isKey, o.childMembers, o.entity, o.exposedItemName}) + return o +} + +// NewDataEntity creates a new DataEntity for user code. Marked dirty (bit 63 = new element). +func NewDataEntity() *DataEntity { + o := initDataEntity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initImportedWebService creates a ImportedWebService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initImportedWebService() *ImportedWebService { + o := &ImportedWebService{} + o.SetTypeName("WebServices$ImportedWebService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.wsdlDescription = property.NewPart[element.Element]("WsdlDescription") + o.wsdlDescription.Bind(&o.Base, 4) + o.wsdlUrl = property.NewPrimitive[string]("WsdlUrl", property.DecodeString) + o.wsdlUrl.Bind(&o.Base, 5) + o.useMtom = property.NewPrimitive[bool]("UseMtom", property.DecodeBool) + o.useMtom.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.wsdlDescription, o.wsdlUrl, o.useMtom}) + return o +} + +// NewImportedWebService creates a new ImportedWebService for user code. Marked dirty (bit 63 = new element). +func NewImportedWebService() *ImportedWebService { + o := initImportedWebService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOperationInfo creates a OperationInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOperationInfo() *OperationInfo { + o := &OperationInfo{} + o.SetTypeName("WebServices$OperationInfo") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.soapAction = property.NewPrimitive[string]("SoapAction", property.DecodeString) + o.soapAction.Bind(&o.Base, 2) + o.requestHeaderRpcElement = property.NewPart[element.Element]("RequestHeaderRpcElement") + o.requestHeaderRpcElement.Bind(&o.Base, 3) + o.requestBodyRpcElement = property.NewPart[element.Element]("RequestBodyRpcElement") + o.requestBodyRpcElement.Bind(&o.Base, 4) + o.responseBodyRpcElement = property.NewPart[element.Element]("ResponseBodyRpcElement") + o.responseBodyRpcElement.Bind(&o.Base, 5) + o.requestHeaderElementName = property.NewPrimitive[string]("RequestHeaderElementName", property.DecodeString) + o.requestHeaderElementName.Bind(&o.Base, 6) + o.requestHeaderEncoded = property.NewPrimitive[bool]("RequestHeaderEncoded", property.DecodeBool) + o.requestHeaderEncoded.Bind(&o.Base, 7) + o.requestHeaderPartEncoding = property.NewPart[element.Element]("RequestHeaderPartEncoding") + o.requestHeaderPartEncoding.Bind(&o.Base, 8) + o.requestBodyEncoded = property.NewPrimitive[bool]("RequestBodyEncoded", property.DecodeBool) + o.requestBodyEncoded.Bind(&o.Base, 9) + o.requestBodyElementName = property.NewPrimitive[string]("RequestBodyElementName", property.DecodeString) + o.requestBodyElementName.Bind(&o.Base, 10) + o.requestBodyPartEncodings = property.NewPartList[element.Element]("RequestBodyPartEncodings") + o.requestBodyPartEncodings.Bind(&o.Base, 11) + o.responseBodyElementName = property.NewPrimitive[string]("ResponseBodyElementName", property.DecodeString) + o.responseBodyElementName.Bind(&o.Base, 12) + o.allowSimpleMappingInheritance = property.NewPrimitive[bool]("AllowSimpleMappingInheritance", property.DecodeBool) + o.allowSimpleMappingInheritance.Bind(&o.Base, 13) + o.SetProperties([]element.Property{o.name, o.documentation, o.soapAction, o.requestHeaderRpcElement, o.requestBodyRpcElement, o.responseBodyRpcElement, o.requestHeaderElementName, o.requestHeaderEncoded, o.requestHeaderPartEncoding, o.requestBodyEncoded, o.requestBodyElementName, o.requestBodyPartEncodings, o.responseBodyElementName, o.allowSimpleMappingInheritance}) + return o +} + +// NewOperationInfo creates a new OperationInfo for user code. Marked dirty (bit 63 = new element). +func NewOperationInfo() *OperationInfo { + o := initOperationInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPartEncoding creates a PartEncoding with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPartEncoding() *PartEncoding { + o := &PartEncoding{} + o.SetTypeName("WebServices$PartEncoding") + o.partName = property.NewPrimitive[string]("PartName", property.DecodeString) + o.partName.Bind(&o.Base, 0) + o.partXsdType = property.NewPrimitive[string]("PartXsdType", property.DecodeString) + o.partXsdType.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.partName, o.partXsdType}) + return o +} + +// NewPartEncoding creates a new PartEncoding for user code. Marked dirty (bit 63 = new element). +func NewPartEncoding() *PartEncoding { + o := initPartEncoding() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedAppService creates a PublishedAppService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedAppService() *PublishedAppService { + o := &PublishedAppService{} + o.SetTypeName("WebServices$PublishedAppService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.versionedServices = property.NewPartList[element.Element]("VersionedServices") + o.versionedServices.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.versionedServices}) + return o +} + +// NewPublishedAppService creates a new PublishedAppService for user code. Marked dirty (bit 63 = new element). +func NewPublishedAppService() *PublishedAppService { + o := initPublishedAppService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedOperation creates a PublishedOperation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedOperation() *PublishedOperation { + o := &PublishedOperation{} + o.SetTypeName("WebServices$PublishedOperationImpl") + o.dataEntity = property.NewPart[element.Element]("DataEntity") + o.dataEntity.Bind(&o.Base, 0) + o.isLockedByContract = property.NewPrimitive[bool]("IsLockedByContract", property.DecodeBool) + o.isLockedByContract.Bind(&o.Base, 1) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 2) + o.image = property.NewByNameRef[element.Element]("Image", "Images$Image") + o.image.Bind(&o.Base, 3) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 4) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 5) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 6) + o.parameters = property.NewPartList[element.Element]("Parameters") + o.parameters.Bind(&o.Base, 7) + o.returnTypeNameByContract = property.NewPrimitive[string]("ReturnTypeNameByContract", property.DecodeString) + o.returnTypeNameByContract.Bind(&o.Base, 8) + o.returnTypeSpecificationByContract = property.NewPrimitive[string]("ReturnTypeSpecificationByContract", property.DecodeString) + o.returnTypeSpecificationByContract.Bind(&o.Base, 9) + o.entityExposedNameByContract = property.NewPrimitive[string]("EntityExposedNameByContract", property.DecodeString) + o.entityExposedNameByContract.Bind(&o.Base, 10) + o.entityExposedName = property.NewPrimitive[string]("EntityExposedName", property.DecodeString) + o.entityExposedName.Bind(&o.Base, 11) + o.returnType = property.NewPrimitive[string]("ReturnType", property.DecodeString) + o.returnType.Bind(&o.Base, 12) + o.operationReturnType = property.NewPart[element.Element]("OperationReturnType") + o.operationReturnType.Bind(&o.Base, 13) + o.returnTypeIsOptional = property.NewPrimitive[bool]("ReturnTypeIsOptional", property.DecodeBool) + o.returnTypeIsOptional.Bind(&o.Base, 14) + o.returnTypeIsNillable = property.NewPrimitive[bool]("ReturnTypeIsNillable", property.DecodeBool) + o.returnTypeIsNillable.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.dataEntity, o.isLockedByContract, o.name, o.image, o.description, o.documentation, o.microflow, o.parameters, o.returnTypeNameByContract, o.returnTypeSpecificationByContract, o.entityExposedNameByContract, o.entityExposedName, o.returnType, o.operationReturnType, o.returnTypeIsOptional, o.returnTypeIsNillable}) + return o +} + +// NewPublishedOperation creates a new PublishedOperation for user code. Marked dirty (bit 63 = new element). +func NewPublishedOperation() *PublishedOperation { + o := initPublishedOperation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedParameter creates a PublishedParameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedParameter() *PublishedParameter { + o := &PublishedParameter{} + o.SetTypeName("WebServices$PublishedParameter") + o.isLockedByContract = property.NewPrimitive[bool]("IsLockedByContract", property.DecodeBool) + o.isLockedByContract.Bind(&o.Base, 0) + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Microflows$MicroflowParameter") + o.parameter.Bind(&o.Base, 1) + o.parameterByContract = property.NewPart[element.Element]("ParameterByContract") + o.parameterByContract.Bind(&o.Base, 2) + o.entityExposedName = property.NewPrimitive[string]("EntityExposedName", property.DecodeString) + o.entityExposedName.Bind(&o.Base, 3) + o.isOptionalByContract = property.NewPrimitive[bool]("IsOptionalByContract", property.DecodeBool) + o.isOptionalByContract.Bind(&o.Base, 4) + o.isOptional = property.NewPrimitive[bool]("IsOptional", property.DecodeBool) + o.isOptional.Bind(&o.Base, 5) + o.isNillable = property.NewPrimitive[bool]("IsNillable", property.DecodeBool) + o.isNillable.Bind(&o.Base, 6) + o.entityExposedItemNameByContract = property.NewPrimitive[string]("EntityExposedItemNameByContract", property.DecodeString) + o.entityExposedItemNameByContract.Bind(&o.Base, 7) + o.entityExposedItemName = property.NewPrimitive[string]("EntityExposedItemName", property.DecodeString) + o.entityExposedItemName.Bind(&o.Base, 8) + o.propType = property.NewPrimitive[string]("Type", property.DecodeString) + o.propType.Bind(&o.Base, 9) + o.parameterType = property.NewPart[element.Element]("ParameterType") + o.parameterType.Bind(&o.Base, 10) + o.dataEntity = property.NewPart[element.Element]("DataEntity") + o.dataEntity.Bind(&o.Base, 11) + o.SetProperties([]element.Property{o.isLockedByContract, o.parameter, o.parameterByContract, o.entityExposedName, o.isOptionalByContract, o.isOptional, o.isNillable, o.entityExposedItemNameByContract, o.entityExposedItemName, o.propType, o.parameterType, o.dataEntity}) + return o +} + +// NewPublishedParameter creates a new PublishedParameter for user code. Marked dirty (bit 63 = new element). +func NewPublishedParameter() *PublishedParameter { + o := initPublishedParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPublishedWebService creates a PublishedWebService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPublishedWebService() *PublishedWebService { + o := &PublishedWebService{} + o.SetTypeName("WebServices$PublishedService") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.versionedServices = property.NewPartList[element.Element]("VersionedServices") + o.versionedServices.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.versionedServices}) + return o +} + +// NewPublishedWebService creates a new PublishedWebService for user code. Marked dirty (bit 63 = new element). +func NewPublishedWebService() *PublishedWebService { + o := initPublishedWebService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRpcMessagePartElement creates a RpcMessagePartElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRpcMessagePartElement() *RpcMessagePartElement { + o := &RpcMessagePartElement{} + o.SetTypeName("WebServices$RpcMessagePartElement") + o.partName = property.NewPrimitive[string]("PartName", property.DecodeString) + o.partName.Bind(&o.Base, 0) + o.propTypeName = property.NewPrimitive[string]("TypeName", property.DecodeString) + o.propTypeName.Bind(&o.Base, 1) + o.elementName = property.NewPrimitive[string]("ElementName", property.DecodeString) + o.elementName.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.partName, o.propTypeName, o.elementName}) + return o +} + +// NewRpcMessagePartElement creates a new RpcMessagePartElement for user code. Marked dirty (bit 63 = new element). +func NewRpcMessagePartElement() *RpcMessagePartElement { + o := initRpcMessagePartElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initRpcOperationElement creates a RpcOperationElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initRpcOperationElement() *RpcOperationElement { + o := &RpcOperationElement{} + o.SetTypeName("WebServices$RpcOperationElement") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.messagePartElements = property.NewPartList[element.Element]("MessagePartElements") + o.messagePartElements.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.name, o.messagePartElements}) + return o +} + +// NewRpcOperationElement creates a new RpcOperationElement for user code. Marked dirty (bit 63 = new element). +func NewRpcOperationElement() *RpcOperationElement { + o := initRpcOperationElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initServiceInfo creates a ServiceInfo with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initServiceInfo() *ServiceInfo { + o := &ServiceInfo{} + o.SetTypeName("WebServices$ServiceInfo") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.portName = property.NewPrimitive[string]("PortName", property.DecodeString) + o.portName.Bind(&o.Base, 2) + o.location = property.NewPrimitive[string]("Location", property.DecodeString) + o.location.Bind(&o.Base, 3) + o.soapVersion = property.NewEnum[string]("SoapVersion") + o.soapVersion.Bind(&o.Base, 4) + o.locationConstant = property.NewByNameRef[element.Element]("LocationConstant", "Constants$Constant") + o.locationConstant.Bind(&o.Base, 5) + o.operations = property.NewPartList[element.Element]("Operations") + o.operations.Bind(&o.Base, 6) + o.usingAddressing = property.NewPrimitive[bool]("UsingAddressing", property.DecodeBool) + o.usingAddressing.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.name, o.documentation, o.portName, o.location, o.soapVersion, o.locationConstant, o.operations, o.usingAddressing}) + return o +} + +// NewServiceInfo creates a new ServiceInfo for user code. Marked dirty (bit 63 = new element). +func NewServiceInfo() *ServiceInfo { + o := initServiceInfo() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSystemIdDataAttribute creates a SystemIdDataAttribute with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSystemIdDataAttribute() *SystemIdDataAttribute { + o := &SystemIdDataAttribute{} + o.SetTypeName("WebServices$SystemIdDataAttribute") + o.isLockedByContract = property.NewPrimitive[bool]("IsLockedByContract", property.DecodeBool) + o.isLockedByContract.Bind(&o.Base, 0) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 1) + o.isOptionalByContract = property.NewPrimitive[bool]("IsOptionalByContract", property.DecodeBool) + o.isOptionalByContract.Bind(&o.Base, 2) + o.isOptional = property.NewPrimitive[bool]("IsOptional", property.DecodeBool) + o.isOptional.Bind(&o.Base, 3) + o.isNillableByContract = property.NewPrimitive[bool]("IsNillableByContract", property.DecodeBool) + o.isNillableByContract.Bind(&o.Base, 4) + o.isNillable = property.NewPrimitive[bool]("IsNillable", property.DecodeBool) + o.isNillable.Bind(&o.Base, 5) + o.isKey = property.NewPrimitive[bool]("IsKey", property.DecodeBool) + o.isKey.Bind(&o.Base, 6) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 7) + o.summary = property.NewPrimitive[string]("Summary", property.DecodeString) + o.summary.Bind(&o.Base, 8) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.isLockedByContract, o.exposedName, o.isOptionalByContract, o.isOptional, o.isNillableByContract, o.isNillable, o.isKey, o.entity, o.summary, o.description}) + return o +} + +// NewSystemIdDataAttribute creates a new SystemIdDataAttribute for user code. Marked dirty (bit 63 = new element). +func NewSystemIdDataAttribute() *SystemIdDataAttribute { + o := initSystemIdDataAttribute() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initVersionedService creates a VersionedService with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initVersionedService() *VersionedService { + o := &VersionedService{} + o.SetTypeName("WebServices$VersionedServiceImpl") + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 0) + o.targetNamespace = property.NewPrimitive[string]("TargetNamespace", property.DecodeString) + o.targetNamespace.Bind(&o.Base, 1) + o.headerAuthentication = property.NewEnum[string]("HeaderAuthentication") + o.headerAuthentication.Bind(&o.Base, 2) + o.operations = property.NewPartList[element.Element]("Operations") + o.operations.Bind(&o.Base, 3) + o.isLockedByContract = property.NewPrimitive[bool]("IsLockedByContract", property.DecodeBool) + o.isLockedByContract.Bind(&o.Base, 4) + o.enumerationsByContract = property.NewPart[element.Element]("EnumerationsByContract") + o.enumerationsByContract.Bind(&o.Base, 5) + o.optimizedXml = property.NewPrimitive[bool]("OptimizedXml", property.DecodeBool) + o.optimizedXml.Bind(&o.Base, 6) + o.headerImportMapping = property.NewByNameRef[element.Element]("HeaderImportMapping", "ImportMappings$ImportMapping") + o.headerImportMapping.Bind(&o.Base, 7) + o.objectHandlingBackup = property.NewEnum[string]("ObjectHandlingBackup") + o.objectHandlingBackup.Bind(&o.Base, 8) + o.headerMicroflow = property.NewByNameRef[element.Element]("HeaderMicroflow", "Microflows$Microflow") + o.headerMicroflow.Bind(&o.Base, 9) + o.versionNumber = property.NewPrimitive[int32]("VersionNumber", property.DecodeInt32) + o.versionNumber.Bind(&o.Base, 10) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 11) + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 12) + o.appServiceState = property.NewEnum[string]("AppServiceState") + o.appServiceState.Bind(&o.Base, 13) + o.image = property.NewByNameRef[element.Element]("Image", "Images$Image") + o.image.Bind(&o.Base, 14) + o.validate = property.NewPrimitive[bool]("Validate", property.DecodeBool) + o.validate.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.documentation, o.targetNamespace, o.headerAuthentication, o.operations, o.isLockedByContract, o.enumerationsByContract, o.optimizedXml, o.headerImportMapping, o.objectHandlingBackup, o.headerMicroflow, o.versionNumber, o.caption, o.description, o.appServiceState, o.image, o.validate}) + return o +} + +// NewVersionedService creates a new VersionedService for user code. Marked dirty (bit 63 = new element). +func NewVersionedService() *VersionedService { + o := initVersionedService() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWsdlDescription creates a WsdlDescription with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWsdlDescription() *WsdlDescription { + o := &WsdlDescription{} + o.SetTypeName("WebServices$WsdlDescription") + o.wsdlEntries = property.NewPartList[element.Element]("WsdlEntries") + o.wsdlEntries.Bind(&o.Base, 0) + o.schemaEntries = property.NewPartList[element.Element]("SchemaEntries") + o.schemaEntries.Bind(&o.Base, 1) + o.services = property.NewPartList[element.Element]("Services") + o.services.Bind(&o.Base, 2) + o.targetNamespace = property.NewPrimitive[string]("TargetNamespace", property.DecodeString) + o.targetNamespace.Bind(&o.Base, 3) + o.importsHaveLocations = property.NewPrimitive[bool]("ImportsHaveLocations", property.DecodeBool) + o.importsHaveLocations.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.wsdlEntries, o.schemaEntries, o.services, o.targetNamespace, o.importsHaveLocations}) + return o +} + +// NewWsdlDescription creates a new WsdlDescription for user code. Marked dirty (bit 63 = new element). +func NewWsdlDescription() *WsdlDescription { + o := initWsdlDescription() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWsdlEntry creates a WsdlEntry with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWsdlEntry() *WsdlEntry { + o := &WsdlEntry{} + o.SetTypeName("WebServices$WsdlEntry") + o.location = property.NewPrimitive[string]("Location", property.DecodeString) + o.location.Bind(&o.Base, 0) + o.contents = property.NewPrimitive[string]("Contents", property.DecodeString) + o.contents.Bind(&o.Base, 1) + o.localizedLocationFormat = property.NewPrimitive[string]("LocalizedLocationFormat", property.DecodeString) + o.localizedLocationFormat.Bind(&o.Base, 2) + o.localizedContentsFormat = property.NewPrimitive[string]("LocalizedContentsFormat", property.DecodeString) + o.localizedContentsFormat.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.location, o.contents, o.localizedLocationFormat, o.localizedContentsFormat}) + return o +} + +// NewWsdlEntry creates a new WsdlEntry for user code. Marked dirty (bit 63 = new element). +func NewWsdlEntry() *WsdlEntry { + o := initWsdlEntry() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("WebServices$DataAssociation", func() element.Element { + o := initDataAssociation() + o.SetTypeName("WebServices$DataAssociation") + return o + }) + codec.DefaultRegistry.Register("WebServices$DataAssociationImpl", func() element.Element { + return initDataAssociation() + }) + codec.DefaultRegistry.Register("WebServices$DataAttribute", func() element.Element { + o := initDataAttribute() + o.SetTypeName("WebServices$DataAttribute") + return o + }) + codec.DefaultRegistry.Register("WebServices$DataAttributeImpl", func() element.Element { + return initDataAttribute() + }) + codec.DefaultRegistry.Register("WebServices$DataEntity", func() element.Element { + o := initDataEntity() + o.SetTypeName("WebServices$DataEntity") + return o + }) + codec.DefaultRegistry.Register("WebServices$DataEntityImpl", func() element.Element { + return initDataEntity() + }) + codec.DefaultRegistry.Register("WebServices$ImportedWebService", func() element.Element { + return initImportedWebService() + }) + codec.DefaultRegistry.Register("WebServices$OperationInfo", func() element.Element { + return initOperationInfo() + }) + codec.DefaultRegistry.Register("WebServices$PartEncoding", func() element.Element { + return initPartEncoding() + }) + codec.DefaultRegistry.Register("WebServices$PublishedAppService", func() element.Element { + return initPublishedAppService() + }) + codec.DefaultRegistry.Register("WebServices$PublishedOperation", func() element.Element { + o := initPublishedOperation() + o.SetTypeName("WebServices$PublishedOperation") + return o + }) + codec.DefaultRegistry.Register("WebServices$PublishedOperationImpl", func() element.Element { + return initPublishedOperation() + }) + codec.DefaultRegistry.Register("WebServices$PublishedParameter", func() element.Element { + return initPublishedParameter() + }) + codec.DefaultRegistry.Register("WebServices$PublishedWebService", func() element.Element { + o := initPublishedWebService() + o.SetTypeName("WebServices$PublishedWebService") + return o + }) + codec.DefaultRegistry.Register("WebServices$PublishedService", func() element.Element { + return initPublishedWebService() + }) + codec.DefaultRegistry.Register("WebServices$RpcMessagePartElement", func() element.Element { + return initRpcMessagePartElement() + }) + codec.DefaultRegistry.Register("WebServices$RpcOperationElement", func() element.Element { + return initRpcOperationElement() + }) + codec.DefaultRegistry.Register("WebServices$ServiceInfo", func() element.Element { + return initServiceInfo() + }) + codec.DefaultRegistry.Register("WebServices$SystemIdDataAttribute", func() element.Element { + return initSystemIdDataAttribute() + }) + codec.DefaultRegistry.Register("WebServices$VersionedService", func() element.Element { + o := initVersionedService() + o.SetTypeName("WebServices$VersionedService") + return o + }) + codec.DefaultRegistry.Register("WebServices$VersionedServiceImpl", func() element.Element { + return initVersionedService() + }) + codec.DefaultRegistry.Register("WebServices$WsdlDescription", func() element.Element { + return initWsdlDescription() + }) + codec.DefaultRegistry.Register("WebServices$WsdlEntry", func() element.Element { + return initWsdlEntry() + }) +} diff --git a/modelsdk/gen/webservices/version.go b/modelsdk/gen/webservices/version.go new file mode 100644 index 00000000..c827e764 --- /dev/null +++ b/modelsdk/gen/webservices/version.go @@ -0,0 +1,132 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package webservices + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "WebServices$DataMember": { + Properties: map[string]version.PropertyVersionInfo{ + "isLockedByContract": {Deleted: "9.0.2"}, + "isNillableByContract": {Deleted: "9.0.2"}, + "isOptionalByContract": {Deleted: "9.0.2"}, + }, + }, + "WebServices$DataAssociation": { + Properties: map[string]version.PropertyVersionInfo{ + "associationByContract": {Deleted: "9.0.2"}, + "description": {Introduced: "8.5.0"}, + "exposedAssociationName": {Introduced: "8.0.0"}, + "summary": {Introduced: "8.5.0"}, + }, + }, + "WebServices$DataAssociationImpl": { + Properties: map[string]version.PropertyVersionInfo{ + "associationByContract": {Deleted: "9.0.2"}, + "description": {Introduced: "8.5.0"}, + "exposedAssociationName": {Introduced: "8.0.0"}, + "summary": {Introduced: "8.5.0"}, + }, + }, + "WebServices$DataAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "attributeByContract": {Deleted: "9.0.2"}, + "description": {Introduced: "8.5.0"}, + "enumerationAsString": {Introduced: "9.21.0"}, + "filterable": {Introduced: "9.18.0"}, + "sortable": {Introduced: "9.18.0"}, + "summary": {Introduced: "8.5.0"}, + }, + }, + "WebServices$DataAttributeImpl": { + Properties: map[string]version.PropertyVersionInfo{ + "attributeByContract": {Deleted: "9.0.2"}, + "description": {Introduced: "8.5.0"}, + "enumerationAsString": {Introduced: "9.21.0"}, + "filterable": {Introduced: "9.18.0"}, + "sortable": {Introduced: "9.18.0"}, + "summary": {Introduced: "8.5.0"}, + }, + }, + "WebServices$ImportedWebService": { + Properties: map[string]version.PropertyVersionInfo{ + "useMtom": {Introduced: "6.4.1"}, + }, + }, + "WebServices$OperationInfo": { + Properties: map[string]version.PropertyVersionInfo{ + "allowSimpleMappingInheritance": {Deleted: "6.1.0"}, + "requestBodyRpcElement": {Required: true}, + "requestHeaderRpcElement": {Required: true}, + "responseBodyRpcElement": {Required: true}, + }, + }, + "WebServices$PublishedResource": { + Properties: map[string]version.PropertyVersionInfo{ + "dataEntity": {Required: true}, + }, + }, + "WebServices$PublishedOperation": { + Properties: map[string]version.PropertyVersionInfo{ + "entityExposedNameByContract": {Deleted: "9.0.2"}, + "isLockedByContract": {Deleted: "9.0.2"}, + "operationReturnType": {Introduced: "7.9.0", Required: true}, + "returnType": {Deleted: "7.9.0"}, + "returnTypeNameByContract": {Deleted: "9.0.2"}, + "returnTypeSpecificationByContract": {Deleted: "9.0.2"}, + }, + }, + "WebServices$PublishedOperationImpl": { + Properties: map[string]version.PropertyVersionInfo{ + "entityExposedNameByContract": {Deleted: "9.0.2"}, + "isLockedByContract": {Deleted: "9.0.2"}, + "operationReturnType": {Introduced: "7.9.0", Required: true}, + "returnType": {Deleted: "7.9.0"}, + "returnTypeNameByContract": {Deleted: "9.0.2"}, + "returnTypeSpecificationByContract": {Deleted: "9.0.2"}, + }, + }, + "WebServices$PublishedParameter": { + Properties: map[string]version.PropertyVersionInfo{ + "dataEntity": {Required: true}, + "entityExposedItemNameByContract": {Deleted: "9.0.2"}, + "isLockedByContract": {Deleted: "9.0.2"}, + "isOptionalByContract": {Deleted: "9.0.2"}, + "parameterByContract": {Deleted: "9.0.2", Required: true}, + "parameterType": {Introduced: "7.9.0", Required: true}, + "type": {Deleted: "7.9.0"}, + }, + }, + "WebServices$ServiceInfo": { + Properties: map[string]version.PropertyVersionInfo{ + "usingAddressing": {Introduced: "8.16.0"}, + }, + }, + "WebServices$SystemIdDataAttribute": { + Properties: map[string]version.PropertyVersionInfo{ + "description": {Introduced: "8.5.0"}, + "summary": {Introduced: "8.5.0"}, + }, + }, + "WebServices$VersionedService": { + Properties: map[string]version.PropertyVersionInfo{ + "appServiceState": {Deleted: "9.0.2"}, + "enumerationsByContract": {Deleted: "9.0.2"}, + "isLockedByContract": {Deleted: "9.0.2"}, + "objectHandlingBackup": {Introduced: "7.17.0"}, + "optimizedXml": {Introduced: "7.13.0"}, + }, + }, + "WebServices$VersionedServiceImpl": { + Properties: map[string]version.PropertyVersionInfo{ + "appServiceState": {Deleted: "9.0.2"}, + "enumerationsByContract": {Deleted: "9.0.2"}, + "isLockedByContract": {Deleted: "9.0.2"}, + "objectHandlingBackup": {Introduced: "7.17.0"}, + "optimizedXml": {Introduced: "7.13.0"}, + }, + }, +} diff --git a/modelsdk/gen/workflows/enums.go b/modelsdk/gen/workflows/enums.go new file mode 100644 index 00000000..875817dd --- /dev/null +++ b/modelsdk/gen/workflows/enums.go @@ -0,0 +1,64 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package workflows + +// CompletionType enumerates the possible values for the CompletionType type. +type CompletionType = string + +const ( + CompletionTypeRelative CompletionType = "Relative" + CompletionTypeAbsolute CompletionType = "Absolute" +) + +// ConnectionSide enumerates the possible values for the ConnectionSide type. +type ConnectionSide = string + +const ( + ConnectionSideTop ConnectionSide = "Top" + ConnectionSideBottom ConnectionSide = "Bottom" + ConnectionSideLeft ConnectionSide = "Left" + ConnectionSideRight ConnectionSide = "Right" +) + +// WorkflowEventType enumerates the possible values for the WorkflowEventType type. +type WorkflowEventType = string + +const ( + WorkflowEventTypeWorkflowCompleted WorkflowEventType = "WorkflowCompleted" + WorkflowEventTypeWorkflowInitiated WorkflowEventType = "WorkflowInitiated" + WorkflowEventTypeWorkflowRestarted WorkflowEventType = "WorkflowRestarted" + WorkflowEventTypeWorkflowFailed WorkflowEventType = "WorkflowFailed" + WorkflowEventTypeWorkflowAborted WorkflowEventType = "WorkflowAborted" + WorkflowEventTypeWorkflowPaused WorkflowEventType = "WorkflowPaused" + WorkflowEventTypeWorkflowUnpaused WorkflowEventType = "WorkflowUnpaused" + WorkflowEventTypeWorkflowRetried WorkflowEventType = "WorkflowRetried" + WorkflowEventTypeWorkflowUpdated WorkflowEventType = "WorkflowUpdated" + WorkflowEventTypeWorkflowUpgraded WorkflowEventType = "WorkflowUpgraded" + WorkflowEventTypeWorkflowConflicted WorkflowEventType = "WorkflowConflicted" + WorkflowEventTypeWorkflowResolved WorkflowEventType = "WorkflowResolved" + WorkflowEventTypeWorkflowJumpToOptionApplied WorkflowEventType = "WorkflowJumpToOptionApplied" + WorkflowEventTypeStartEventExecuted WorkflowEventType = "StartEventExecuted" + WorkflowEventTypeEndEventExecuted WorkflowEventType = "EndEventExecuted" + WorkflowEventTypeDecisionExecuted WorkflowEventType = "DecisionExecuted" + WorkflowEventTypeJumpExecuted WorkflowEventType = "JumpExecuted" + WorkflowEventTypeParallelSplitExecuted WorkflowEventType = "ParallelSplitExecuted" + WorkflowEventTypeParallelMergeExecuted WorkflowEventType = "ParallelMergeExecuted" + WorkflowEventTypeCallWorkflowStarted WorkflowEventType = "CallWorkflowStarted" + WorkflowEventTypeCallWorkflowEnded WorkflowEventType = "CallWorkflowEnded" + WorkflowEventTypeCallMicroflowStarted WorkflowEventType = "CallMicroflowStarted" + WorkflowEventTypeCallMicroflowEnded WorkflowEventType = "CallMicroflowEnded" + WorkflowEventTypeAIAgentTaskStarted WorkflowEventType = "AIAgentTaskStarted" + WorkflowEventTypeAIAgentTaskEnded WorkflowEventType = "AIAgentTaskEnded" + WorkflowEventTypeWaitForNotificationStarted WorkflowEventType = "WaitForNotificationStarted" + WorkflowEventTypeWaitForNotificationEnded WorkflowEventType = "WaitForNotificationEnded" + WorkflowEventTypeWaitForTimerStarted WorkflowEventType = "WaitForTimerStarted" + WorkflowEventTypeWaitForTimerEnded WorkflowEventType = "WaitForTimerEnded" + WorkflowEventTypeUserTaskStarted WorkflowEventType = "UserTaskStarted" + WorkflowEventTypeMultiUserTaskOutcomeSelected WorkflowEventType = "MultiUserTaskOutcomeSelected" + WorkflowEventTypeUserTaskEnded WorkflowEventType = "UserTaskEnded" + WorkflowEventTypeNonInterruptingTimerEventExecuted WorkflowEventType = "NonInterruptingTimerEventExecuted" + WorkflowEventTypeInterruptingTimerEventExecuted WorkflowEventType = "InterruptingTimerEventExecuted" + WorkflowEventTypeNonInterruptingNotificationEventSubProcessStartExecuted WorkflowEventType = "NonInterruptingNotificationEventSubProcessStartExecuted" +) diff --git a/modelsdk/gen/workflows/ext.go b/modelsdk/gen/workflows/ext.go new file mode 100644 index 00000000..d9ffc70d --- /dev/null +++ b/modelsdk/gen/workflows/ext.go @@ -0,0 +1,8 @@ +package workflows + +import "github.com/mendixlabs/mxcli/modelsdk/element" + +// InsertActivitiesAt inserts an activity at the given index in the Flow's activities list. +func (o *Flow) InsertActivitiesAt(index int, v element.Element) { + o.activities.InsertAt(index, v) +} diff --git a/modelsdk/gen/workflows/refs.go b/modelsdk/gen/workflows/refs.go new file mode 100644 index 00000000..99069dc7 --- /dev/null +++ b/modelsdk/gen/workflows/refs.go @@ -0,0 +1,106 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package workflows + +import "github.com/mendixlabs/mxcli/modelsdk/codec" + +func init() { + codec.DefaultRefRegistry.RegisterRefs("Workflows$MicroflowBasedActivity", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$AIAgentTaskActivity", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$CallMicroflowActivity", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$CallMicroflowTask", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$CallWorkflowActivity", []codec.RefMeta{ + {Prop: "Workflow", Kind: codec.RefByName, Target: "Workflows$Workflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$ConsensusCompletionCriteria", []codec.RefMeta{ + {Prop: "FallbackOutcomePointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$EnumerationValueConditionOutcome", []codec.RefMeta{ + {Prop: "Value", Kind: codec.RefByName, Target: "Enumerations$EnumerationValue"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$FlowLine", []codec.RefMeta{ + {Prop: "OriginPointer", Kind: codec.RefById, Target: ""}, + {Prop: "DestinationPointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$JumpToActivity", []codec.RefMeta{ + {Prop: "TargetActivity", Kind: codec.RefByName, Target: "Workflows$WorkflowActivity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$MajorityCompletionCriteria", []codec.RefMeta{ + {Prop: "FallbackOutcomePointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$MicroflowBasedEvent", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$MicroflowBasedTargeting", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$MicroflowBasedUserSource", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$MicroflowCallParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Microflows$MicroflowParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$MicroflowCompletionCriteria", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$MicroflowEventHandler", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$MicroflowGroupTargeting", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$MicroflowUserTargeting", []codec.RefMeta{ + {Prop: "Microflow", Kind: codec.RefByName, Target: "Microflows$Microflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$NonInterruptingNotificationEventSubProcessStartActivityTarget", []codec.RefMeta{ + {Prop: "Activity", Kind: codec.RefByName, Target: "Workflows$NonInterruptingNotificationEventSubProcessStartActivity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$NotifyWaitForNotificationActivityTarget", []codec.RefMeta{ + {Prop: "Activity", Kind: codec.RefByName, Target: "Workflows$WaitForNotificationActivity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$PageParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Forms$PageParameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$PageReference", []codec.RefMeta{ + {Prop: "Page", Kind: codec.RefByName, Target: "Forms$Page"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$Parameter", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$ThresholdCompletionCriteria", []codec.RefMeta{ + {Prop: "FallbackOutcomePointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$UserTask", []codec.RefMeta{ + {Prop: "UserTaskEntity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "Page", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "AllowedModuleRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$VetoCompletionCriteria", []codec.RefMeta{ + {Prop: "VetoOutcomePointer", Kind: codec.RefById, Target: ""}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$Workflow", []codec.RefMeta{ + {Prop: "ContextEntity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "WorkflowEntity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + {Prop: "OverviewPage", Kind: codec.RefByName, Target: "Forms$Page"}, + {Prop: "AllowedModuleRoles", Kind: codec.RefByNameList, Target: "Security$ModuleRole"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$WorkflowCallParameterMapping", []codec.RefMeta{ + {Prop: "Parameter", Kind: codec.RefByName, Target: "Workflows$Parameter"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$WorkflowDefinitionNameSelection", []codec.RefMeta{ + {Prop: "Workflow", Kind: codec.RefByName, Target: "Workflows$Workflow"}, + }) + codec.DefaultRefRegistry.RegisterRefs("Workflows$WorkflowType", []codec.RefMeta{ + {Prop: "Entity", Kind: codec.RefByName, Target: "DomainModels$Entity"}, + }) +} diff --git a/modelsdk/gen/workflows/types.go b/modelsdk/gen/workflows/types.go new file mode 100644 index 00000000..6bff63b8 --- /dev/null +++ b/modelsdk/gen/workflows/types.go @@ -0,0 +1,8197 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package workflows + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// WorkflowActivity +// ──────────────────────────────────────────────────────── + +type WorkflowActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *WorkflowActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *WorkflowActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *WorkflowActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *WorkflowActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *WorkflowActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *WorkflowActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *WorkflowActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *WorkflowActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *WorkflowActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *WorkflowActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *WorkflowActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *WorkflowActivity) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ConditionOutcomeActivity +// ──────────────────────────────────────────────────────── + +type ConditionOutcomeActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + outcomes *property.PartList[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *ConditionOutcomeActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *ConditionOutcomeActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *ConditionOutcomeActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ConditionOutcomeActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ConditionOutcomeActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ConditionOutcomeActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *ConditionOutcomeActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *ConditionOutcomeActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *ConditionOutcomeActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *ConditionOutcomeActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *ConditionOutcomeActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *ConditionOutcomeActivity) SetSize(v string) { + o.size.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *ConditionOutcomeActivity) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *ConditionOutcomeActivity) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *ConditionOutcomeActivity) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConditionOutcomeActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowBasedActivity +// ──────────────────────────────────────────────────────── + +type MicroflowBasedActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + outcomes *property.PartList[element.Element] + microflow *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] + boundaryEvents *property.PartList[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *MicroflowBasedActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *MicroflowBasedActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *MicroflowBasedActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MicroflowBasedActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *MicroflowBasedActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *MicroflowBasedActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *MicroflowBasedActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *MicroflowBasedActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *MicroflowBasedActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *MicroflowBasedActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *MicroflowBasedActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *MicroflowBasedActivity) SetSize(v string) { + o.size.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *MicroflowBasedActivity) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *MicroflowBasedActivity) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *MicroflowBasedActivity) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowBasedActivity) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowBasedActivity) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *MicroflowBasedActivity) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *MicroflowBasedActivity) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *MicroflowBasedActivity) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// BoundaryEventsItems returns the value of the boundaryEvents property. +func (o *MicroflowBasedActivity) BoundaryEventsItems() []element.Element { + return o.boundaryEvents.Items() +} + +// AddBoundaryEvents appends a child element to the boundaryEvents list. +func (o *MicroflowBasedActivity) AddBoundaryEvents(v element.Element) { + o.boundaryEvents.Append(v) +} + +// RemoveBoundaryEvents removes the element at the given index from the boundaryEvents list. +func (o *MicroflowBasedActivity) RemoveBoundaryEvents(index int) { + o.boundaryEvents.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowBasedActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "BoundaryEvents"); err == nil { + for _, child := range children { + o.boundaryEvents.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// AIAgentTaskActivity +// ──────────────────────────────────────────────────────── + +type AIAgentTaskActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + outcomes *property.PartList[element.Element] + microflow *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] + boundaryEvents *property.PartList[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *AIAgentTaskActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *AIAgentTaskActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *AIAgentTaskActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *AIAgentTaskActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *AIAgentTaskActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *AIAgentTaskActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *AIAgentTaskActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *AIAgentTaskActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *AIAgentTaskActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *AIAgentTaskActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *AIAgentTaskActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *AIAgentTaskActivity) SetSize(v string) { + o.size.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *AIAgentTaskActivity) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *AIAgentTaskActivity) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *AIAgentTaskActivity) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *AIAgentTaskActivity) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *AIAgentTaskActivity) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *AIAgentTaskActivity) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *AIAgentTaskActivity) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *AIAgentTaskActivity) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// BoundaryEventsItems returns the value of the boundaryEvents property. +func (o *AIAgentTaskActivity) BoundaryEventsItems() []element.Element { + return o.boundaryEvents.Items() +} + +// AddBoundaryEvents appends a child element to the boundaryEvents list. +func (o *AIAgentTaskActivity) AddBoundaryEvents(v element.Element) { + o.boundaryEvents.Append(v) +} + +// RemoveBoundaryEvents removes the element at the given index from the boundaryEvents list. +func (o *AIAgentTaskActivity) RemoveBoundaryEvents(index int) { + o.boundaryEvents.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AIAgentTaskActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "BoundaryEvents"); err == nil { + for _, child := range children { + o.boundaryEvents.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// TargetUserInput +// ──────────────────────────────────────────────────────── + +type TargetUserInput struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TargetUserInput) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// AbsoluteAmountUserInput +// ──────────────────────────────────────────────────────── + +type AbsoluteAmountUserInput struct { + element.Base + amount *property.Primitive[int32] +} + +// Amount returns the value of the amount property. +func (o *AbsoluteAmountUserInput) Amount() int32 { + return o.amount.Get() +} + +// SetAmount sets the value of the amount property. +func (o *AbsoluteAmountUserInput) SetAmount(v int32) { + o.amount.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AbsoluteAmountUserInput) InitFromRaw(raw bson.Raw) { + o.amount.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// AllUserInput +// ──────────────────────────────────────────────────────── + +type AllUserInput struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *AllUserInput) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// Annotation +// ──────────────────────────────────────────────────────── + +type Annotation struct { + element.Base + description *property.Primitive[string] +} + +// Description returns the value of the description property. +func (o *Annotation) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *Annotation) SetDescription(v string) { + o.description.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Annotation) InitFromRaw(raw bson.Raw) { + o.description.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Line +// ──────────────────────────────────────────────────────── + +type Line struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Line) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BezierCurve +// ──────────────────────────────────────────────────────── + +type BezierCurve struct { + element.Base + originControlVector *property.Primitive[string] + destinationControlVector *property.Primitive[string] +} + +// OriginControlVector returns the value of the originControlVector property. +func (o *BezierCurve) OriginControlVector() string { + return o.originControlVector.Get() +} + +// SetOriginControlVector sets the value of the originControlVector property. +func (o *BezierCurve) SetOriginControlVector(v string) { + o.originControlVector.Set(v) +} + +// DestinationControlVector returns the value of the destinationControlVector property. +func (o *BezierCurve) DestinationControlVector() string { + return o.destinationControlVector.Get() +} + +// SetDestinationControlVector sets the value of the destinationControlVector property. +func (o *BezierCurve) SetDestinationControlVector(v string) { + o.destinationControlVector.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BezierCurve) InitFromRaw(raw bson.Raw) { + o.originControlVector.Init(raw) + o.destinationControlVector.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CaseValue +// ──────────────────────────────────────────────────────── + +type CaseValue struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CaseValue) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// BooleanCase +// ──────────────────────────────────────────────────────── + +type BooleanCase struct { + element.Base + value *property.Primitive[bool] +} + +// Value returns the value of the value property. +func (o *BooleanCase) Value() bool { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *BooleanCase) SetValue(v bool) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BooleanCase) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Outcome +// ──────────────────────────────────────────────────────── + +type Outcome struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *Outcome) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *Outcome) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *Outcome) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *Outcome) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Outcome) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ConditionOutcome +// ──────────────────────────────────────────────────────── + +type ConditionOutcome struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *ConditionOutcome) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *ConditionOutcome) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *ConditionOutcome) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *ConditionOutcome) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConditionOutcome) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// BooleanConditionOutcome +// ──────────────────────────────────────────────────────── + +type BooleanConditionOutcome struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] + value *property.Primitive[bool] +} + +// PersistentId returns the value of the persistentId property. +func (o *BooleanConditionOutcome) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *BooleanConditionOutcome) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *BooleanConditionOutcome) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *BooleanConditionOutcome) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// Value returns the value of the value property. +func (o *BooleanConditionOutcome) Value() bool { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *BooleanConditionOutcome) SetValue(v bool) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BooleanConditionOutcome) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// BoundaryEvent +// ──────────────────────────────────────────────────────── + +type BoundaryEvent struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + isInterrupting *property.Primitive[bool] + eventType *property.Primitive[string] + delay *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *BoundaryEvent) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *BoundaryEvent) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *BoundaryEvent) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *BoundaryEvent) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// Caption returns the value of the caption property. +func (o *BoundaryEvent) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *BoundaryEvent) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *BoundaryEvent) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *BoundaryEvent) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// IsInterrupting returns the value of the isInterrupting property. +func (o *BoundaryEvent) IsInterrupting() bool { + return o.isInterrupting.Get() +} + +// SetIsInterrupting sets the value of the isInterrupting property. +func (o *BoundaryEvent) SetIsInterrupting(v bool) { + o.isInterrupting.Set(v) +} + +// EventType returns the value of the eventType property. +func (o *BoundaryEvent) EventType() string { + return o.eventType.Get() +} + +// SetEventType sets the value of the eventType property. +func (o *BoundaryEvent) SetEventType(v string) { + o.eventType.Set(v) +} + +// Delay returns the value of the delay property. +func (o *BoundaryEvent) Delay() string { + return o.delay.Get() +} + +// SetDelay sets the value of the delay property. +func (o *BoundaryEvent) SetDelay(v string) { + o.delay.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *BoundaryEvent) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.isInterrupting.Init(raw) + o.eventType.Init(raw) + o.delay.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// CallMicroflowActivity +// ──────────────────────────────────────────────────────── + +type CallMicroflowActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + outcomes *property.PartList[element.Element] + microflow *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] + boundaryEvents *property.PartList[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *CallMicroflowActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *CallMicroflowActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *CallMicroflowActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CallMicroflowActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *CallMicroflowActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *CallMicroflowActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *CallMicroflowActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *CallMicroflowActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *CallMicroflowActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *CallMicroflowActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *CallMicroflowActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *CallMicroflowActivity) SetSize(v string) { + o.size.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *CallMicroflowActivity) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *CallMicroflowActivity) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *CallMicroflowActivity) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *CallMicroflowActivity) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *CallMicroflowActivity) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *CallMicroflowActivity) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *CallMicroflowActivity) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *CallMicroflowActivity) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// BoundaryEventsItems returns the value of the boundaryEvents property. +func (o *CallMicroflowActivity) BoundaryEventsItems() []element.Element { + return o.boundaryEvents.Items() +} + +// AddBoundaryEvents appends a child element to the boundaryEvents list. +func (o *CallMicroflowActivity) AddBoundaryEvents(v element.Element) { + o.boundaryEvents.Append(v) +} + +// RemoveBoundaryEvents removes the element at the given index from the boundaryEvents list. +func (o *CallMicroflowActivity) RemoveBoundaryEvents(index int) { + o.boundaryEvents.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CallMicroflowActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "BoundaryEvents"); err == nil { + for _, child := range children { + o.boundaryEvents.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// CallMicroflowTask +// ──────────────────────────────────────────────────────── + +type CallMicroflowTask struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + outcomes *property.PartList[element.Element] + microflow *property.ByNameRef[element.Element] + parameterMappings *property.PartList[element.Element] + boundaryEvents *property.PartList[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *CallMicroflowTask) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *CallMicroflowTask) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *CallMicroflowTask) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CallMicroflowTask) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *CallMicroflowTask) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *CallMicroflowTask) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *CallMicroflowTask) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *CallMicroflowTask) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *CallMicroflowTask) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *CallMicroflowTask) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *CallMicroflowTask) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *CallMicroflowTask) SetSize(v string) { + o.size.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *CallMicroflowTask) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *CallMicroflowTask) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *CallMicroflowTask) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *CallMicroflowTask) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *CallMicroflowTask) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *CallMicroflowTask) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *CallMicroflowTask) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *CallMicroflowTask) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// BoundaryEventsItems returns the value of the boundaryEvents property. +func (o *CallMicroflowTask) BoundaryEventsItems() []element.Element { + return o.boundaryEvents.Items() +} + +// AddBoundaryEvents appends a child element to the boundaryEvents list. +func (o *CallMicroflowTask) AddBoundaryEvents(v element.Element) { + o.boundaryEvents.Append(v) +} + +// RemoveBoundaryEvents removes the element at the given index from the boundaryEvents list. +func (o *CallMicroflowTask) RemoveBoundaryEvents(index int) { + o.boundaryEvents.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CallMicroflowTask) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "BoundaryEvents"); err == nil { + for _, child := range children { + o.boundaryEvents.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// CallWorkflowActivity +// ──────────────────────────────────────────────────────── + +type CallWorkflowActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + workflow *property.ByNameRef[element.Element] + parameterExpression *property.Primitive[string] + parameterMappings *property.PartList[element.Element] + boundaryEvents *property.PartList[element.Element] + executeAsync *property.Primitive[bool] +} + +// PersistentId returns the value of the persistentId property. +func (o *CallWorkflowActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *CallWorkflowActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *CallWorkflowActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *CallWorkflowActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *CallWorkflowActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *CallWorkflowActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *CallWorkflowActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *CallWorkflowActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *CallWorkflowActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *CallWorkflowActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *CallWorkflowActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *CallWorkflowActivity) SetSize(v string) { + o.size.Set(v) +} + +// WorkflowQualifiedName returns the value of the workflow property. +func (o *CallWorkflowActivity) WorkflowQualifiedName() string { + return o.workflow.QualifiedName() +} + +// SetWorkflowQualifiedName sets the value of the workflow property. +func (o *CallWorkflowActivity) SetWorkflowQualifiedName(v string) { + o.workflow.SetQualifiedName(v) +} + +// ParameterExpression returns the value of the parameterExpression property. +func (o *CallWorkflowActivity) ParameterExpression() string { + return o.parameterExpression.Get() +} + +// SetParameterExpression sets the value of the parameterExpression property. +func (o *CallWorkflowActivity) SetParameterExpression(v string) { + o.parameterExpression.Set(v) +} + +// ParameterMappingsItems returns the value of the parameterMappings property. +func (o *CallWorkflowActivity) ParameterMappingsItems() []element.Element { + return o.parameterMappings.Items() +} + +// AddParameterMappings appends a child element to the parameterMappings list. +func (o *CallWorkflowActivity) AddParameterMappings(v element.Element) { + o.parameterMappings.Append(v) +} + +// RemoveParameterMappings removes the element at the given index from the parameterMappings list. +func (o *CallWorkflowActivity) RemoveParameterMappings(index int) { + o.parameterMappings.Remove(index) +} + +// BoundaryEventsItems returns the value of the boundaryEvents property. +func (o *CallWorkflowActivity) BoundaryEventsItems() []element.Element { + return o.boundaryEvents.Items() +} + +// AddBoundaryEvents appends a child element to the boundaryEvents list. +func (o *CallWorkflowActivity) AddBoundaryEvents(v element.Element) { + o.boundaryEvents.Append(v) +} + +// RemoveBoundaryEvents removes the element at the given index from the boundaryEvents list. +func (o *CallWorkflowActivity) RemoveBoundaryEvents(index int) { + o.boundaryEvents.Remove(index) +} + +// ExecuteAsync returns the value of the executeAsync property. +func (o *CallWorkflowActivity) ExecuteAsync() bool { + return o.executeAsync.Get() +} + +// SetExecuteAsync sets the value of the executeAsync property. +func (o *CallWorkflowActivity) SetExecuteAsync(v bool) { + o.executeAsync.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *CallWorkflowActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if val, err := raw.LookupErr("Workflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.workflow.SetFromDecode(s) } + } + o.parameterExpression.Init(raw) + if children, err := codec.DecodeChildren(raw, "ParameterMappings"); err == nil { + for _, child := range children { + o.parameterMappings.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "BoundaryEvents"); err == nil { + for _, child := range children { + o.boundaryEvents.AppendFromDecode(child) + } + } + o.executeAsync.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// UserTaskCompletionCriteria +// ──────────────────────────────────────────────────────── + +type UserTaskCompletionCriteria struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserTaskCompletionCriteria) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// ConsensusCompletionCriteria +// ──────────────────────────────────────────────────────── + +type ConsensusCompletionCriteria struct { + element.Base + fallbackOutcome *property.ByIdRef[element.Element] +} + +// FallbackOutcomeRefID returns the value of the fallbackOutcome property. +func (o *ConsensusCompletionCriteria) FallbackOutcomeRefID() element.ID { + return o.fallbackOutcome.RefID() +} + +// SetFallbackOutcomeID sets the value of the fallbackOutcome property. +func (o *ConsensusCompletionCriteria) SetFallbackOutcomeID(v element.ID) { + o.fallbackOutcome.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ConsensusCompletionCriteria) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("FallbackOutcomePointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.fallbackOutcome.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.fallbackOutcome.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// UserSource +// ──────────────────────────────────────────────────────── + +type UserSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EmptyUserSource +// ──────────────────────────────────────────────────────── + +type EmptyUserSource struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EmptyUserSource) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// EndOfBoundaryEventPathActivity +// ──────────────────────────────────────────────────────── + +type EndOfBoundaryEventPathActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *EndOfBoundaryEventPathActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *EndOfBoundaryEventPathActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *EndOfBoundaryEventPathActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *EndOfBoundaryEventPathActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *EndOfBoundaryEventPathActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *EndOfBoundaryEventPathActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *EndOfBoundaryEventPathActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *EndOfBoundaryEventPathActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *EndOfBoundaryEventPathActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *EndOfBoundaryEventPathActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *EndOfBoundaryEventPathActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *EndOfBoundaryEventPathActivity) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EndOfBoundaryEventPathActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EndOfParallelSplitPathActivity +// ──────────────────────────────────────────────────────── + +type EndOfParallelSplitPathActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *EndOfParallelSplitPathActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *EndOfParallelSplitPathActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *EndOfParallelSplitPathActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *EndOfParallelSplitPathActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *EndOfParallelSplitPathActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *EndOfParallelSplitPathActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *EndOfParallelSplitPathActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *EndOfParallelSplitPathActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *EndOfParallelSplitPathActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *EndOfParallelSplitPathActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *EndOfParallelSplitPathActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *EndOfParallelSplitPathActivity) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EndOfParallelSplitPathActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EndWorkflowActivity +// ──────────────────────────────────────────────────────── + +type EndWorkflowActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *EndWorkflowActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *EndWorkflowActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *EndWorkflowActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *EndWorkflowActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *EndWorkflowActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *EndWorkflowActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *EndWorkflowActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *EndWorkflowActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *EndWorkflowActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *EndWorkflowActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *EndWorkflowActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *EndWorkflowActivity) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EndWorkflowActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// EnumerationValueConditionOutcome +// ──────────────────────────────────────────────────────── + +type EnumerationValueConditionOutcome struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] + value *property.ByNameRef[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *EnumerationValueConditionOutcome) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *EnumerationValueConditionOutcome) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *EnumerationValueConditionOutcome) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *EnumerationValueConditionOutcome) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// ValueQualifiedName returns the value of the value property. +func (o *EnumerationValueConditionOutcome) ValueQualifiedName() string { + return o.value.QualifiedName() +} + +// SetValueQualifiedName sets the value of the value property. +func (o *EnumerationValueConditionOutcome) SetValueQualifiedName(v string) { + o.value.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EnumerationValueConditionOutcome) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } + if val, err := raw.LookupErr("Value"); err == nil { + if s, ok := val.StringValueOK(); ok { o.value.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// EventSubProcess +// ──────────────────────────────────────────────────────── + +type EventSubProcess struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + flow *property.Part[element.Element] + caption *property.Primitive[string] + annotation *property.Part[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *EventSubProcess) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *EventSubProcess) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *EventSubProcess) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *EventSubProcess) SetName(v string) { + o.name.Set(v) +} + +// Flow returns the value of the flow property. +func (o *EventSubProcess) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *EventSubProcess) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// Caption returns the value of the caption property. +func (o *EventSubProcess) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *EventSubProcess) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *EventSubProcess) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *EventSubProcess) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *EventSubProcess) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// ExclusiveSplitActivity +// ──────────────────────────────────────────────────────── + +type ExclusiveSplitActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + outcomes *property.PartList[element.Element] + expression *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *ExclusiveSplitActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *ExclusiveSplitActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *ExclusiveSplitActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ExclusiveSplitActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ExclusiveSplitActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ExclusiveSplitActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *ExclusiveSplitActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *ExclusiveSplitActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *ExclusiveSplitActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *ExclusiveSplitActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *ExclusiveSplitActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *ExclusiveSplitActivity) SetSize(v string) { + o.size.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *ExclusiveSplitActivity) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *ExclusiveSplitActivity) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *ExclusiveSplitActivity) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// Expression returns the value of the expression property. +func (o *ExclusiveSplitActivity) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *ExclusiveSplitActivity) SetExpression(v string) { + o.expression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExclusiveSplitActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } + o.expression.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// FloatingAnnotation +// ──────────────────────────────────────────────────────── + +type FloatingAnnotation struct { + element.Base + description *property.Primitive[string] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// Description returns the value of the description property. +func (o *FloatingAnnotation) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *FloatingAnnotation) SetDescription(v string) { + o.description.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *FloatingAnnotation) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *FloatingAnnotation) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *FloatingAnnotation) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *FloatingAnnotation) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FloatingAnnotation) InitFromRaw(raw bson.Raw) { + o.description.Init(raw) + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Flow +// ──────────────────────────────────────────────────────── + +type Flow struct { + element.Base + activities *property.PartList[element.Element] +} + +// ActivitiesItems returns the value of the activities property. +func (o *Flow) ActivitiesItems() []element.Element { + return o.activities.Items() +} + +// AddActivities appends a child element to the activities list. +func (o *Flow) AddActivities(v element.Element) { + o.activities.Append(v) +} + +// RemoveActivities removes the element at the given index from the activities list. +func (o *Flow) RemoveActivities(index int) { + o.activities.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Flow) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "Activities"); err == nil { + for _, child := range children { + o.activities.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// FlowLine +// ──────────────────────────────────────────────────────── + +type FlowLine struct { + element.Base + origin *property.ByIdRef[element.Element] + destination *property.ByIdRef[element.Element] + line *property.Part[element.Element] + originConnectionSide *property.Enum[string] + originalConnectionFactor *property.Primitive[float64] + destinationConnectionSide *property.Enum[string] + destinationConnectionFactor *property.Primitive[float64] + caseValues *property.PartList[element.Element] +} + +// OriginRefID returns the value of the origin property. +func (o *FlowLine) OriginRefID() element.ID { + return o.origin.RefID() +} + +// SetOriginID sets the value of the origin property. +func (o *FlowLine) SetOriginID(v element.ID) { + o.origin.SetID(v) +} + +// DestinationRefID returns the value of the destination property. +func (o *FlowLine) DestinationRefID() element.ID { + return o.destination.RefID() +} + +// SetDestinationID sets the value of the destination property. +func (o *FlowLine) SetDestinationID(v element.ID) { + o.destination.SetID(v) +} + +// Line returns the value of the line property. +func (o *FlowLine) Line() element.Element { + return o.line.Get() +} + +// SetLine sets the value of the line property. +func (o *FlowLine) SetLine(v element.Element) { + o.line.Set(v) +} + +// OriginConnectionSide returns the value of the originConnectionSide property. +func (o *FlowLine) OriginConnectionSide() string { + return o.originConnectionSide.Get() +} + +// SetOriginConnectionSide sets the value of the originConnectionSide property. +func (o *FlowLine) SetOriginConnectionSide(v string) { + o.originConnectionSide.Set(v) +} + +// OriginalConnectionFactor returns the value of the originalConnectionFactor property. +func (o *FlowLine) OriginalConnectionFactor() float64 { + return o.originalConnectionFactor.Get() +} + +// SetOriginalConnectionFactor sets the value of the originalConnectionFactor property. +func (o *FlowLine) SetOriginalConnectionFactor(v float64) { + o.originalConnectionFactor.Set(v) +} + +// DestinationConnectionSide returns the value of the destinationConnectionSide property. +func (o *FlowLine) DestinationConnectionSide() string { + return o.destinationConnectionSide.Get() +} + +// SetDestinationConnectionSide sets the value of the destinationConnectionSide property. +func (o *FlowLine) SetDestinationConnectionSide(v string) { + o.destinationConnectionSide.Set(v) +} + +// DestinationConnectionFactor returns the value of the destinationConnectionFactor property. +func (o *FlowLine) DestinationConnectionFactor() float64 { + return o.destinationConnectionFactor.Get() +} + +// SetDestinationConnectionFactor sets the value of the destinationConnectionFactor property. +func (o *FlowLine) SetDestinationConnectionFactor(v float64) { + o.destinationConnectionFactor.Set(v) +} + +// CaseValuesItems returns the value of the caseValues property. +func (o *FlowLine) CaseValuesItems() []element.Element { + return o.caseValues.Items() +} + +// AddCaseValues appends a child element to the caseValues list. +func (o *FlowLine) AddCaseValues(v element.Element) { + o.caseValues.Append(v) +} + +// RemoveCaseValues removes the element at the given index from the caseValues list. +func (o *FlowLine) RemoveCaseValues(index int) { + o.caseValues.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *FlowLine) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("OriginPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.origin.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.origin.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + if val, err := raw.LookupErr("DestinationPointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.destination.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.destination.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } + if child, err := codec.DecodeChild(raw, "Line"); err == nil { + o.line.SetFromDecode(child) + } + if val, err := raw.LookupErr("OriginConnectionSide"); err == nil { + if s, ok := val.StringValueOK(); ok { o.originConnectionSide.SetFromDecode(s) } + } + o.originalConnectionFactor.Init(raw) + if val, err := raw.LookupErr("DestinationConnectionSide"); err == nil { + if s, ok := val.StringValueOK(); ok { o.destinationConnectionSide.SetFromDecode(s) } + } + o.destinationConnectionFactor.Init(raw) + if children, err := codec.DecodeChildren(raw, "CaseValues"); err == nil { + for _, child := range children { + o.caseValues.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// InterruptingTimerBoundaryEvent +// ──────────────────────────────────────────────────────── + +type InterruptingTimerBoundaryEvent struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + isInterrupting *property.Primitive[bool] + eventType *property.Primitive[string] + delay *property.Primitive[string] + firstExecutionTime *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *InterruptingTimerBoundaryEvent) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *InterruptingTimerBoundaryEvent) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *InterruptingTimerBoundaryEvent) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *InterruptingTimerBoundaryEvent) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// Caption returns the value of the caption property. +func (o *InterruptingTimerBoundaryEvent) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *InterruptingTimerBoundaryEvent) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *InterruptingTimerBoundaryEvent) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *InterruptingTimerBoundaryEvent) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// IsInterrupting returns the value of the isInterrupting property. +func (o *InterruptingTimerBoundaryEvent) IsInterrupting() bool { + return o.isInterrupting.Get() +} + +// SetIsInterrupting sets the value of the isInterrupting property. +func (o *InterruptingTimerBoundaryEvent) SetIsInterrupting(v bool) { + o.isInterrupting.Set(v) +} + +// EventType returns the value of the eventType property. +func (o *InterruptingTimerBoundaryEvent) EventType() string { + return o.eventType.Get() +} + +// SetEventType sets the value of the eventType property. +func (o *InterruptingTimerBoundaryEvent) SetEventType(v string) { + o.eventType.Set(v) +} + +// Delay returns the value of the delay property. +func (o *InterruptingTimerBoundaryEvent) Delay() string { + return o.delay.Get() +} + +// SetDelay sets the value of the delay property. +func (o *InterruptingTimerBoundaryEvent) SetDelay(v string) { + o.delay.Set(v) +} + +// FirstExecutionTime returns the value of the firstExecutionTime property. +func (o *InterruptingTimerBoundaryEvent) FirstExecutionTime() string { + return o.firstExecutionTime.Get() +} + +// SetFirstExecutionTime sets the value of the firstExecutionTime property. +func (o *InterruptingTimerBoundaryEvent) SetFirstExecutionTime(v string) { + o.firstExecutionTime.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *InterruptingTimerBoundaryEvent) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.isInterrupting.Init(raw) + o.eventType.Init(raw) + o.delay.Init(raw) + o.firstExecutionTime.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// JumpToActivity +// ──────────────────────────────────────────────────────── + +type JumpToActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + targetActivity *property.ByNameRef[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *JumpToActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *JumpToActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *JumpToActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *JumpToActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *JumpToActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *JumpToActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *JumpToActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *JumpToActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *JumpToActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *JumpToActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *JumpToActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *JumpToActivity) SetSize(v string) { + o.size.Set(v) +} + +// TargetActivityQualifiedName returns the value of the targetActivity property. +func (o *JumpToActivity) TargetActivityQualifiedName() string { + return o.targetActivity.QualifiedName() +} + +// SetTargetActivityQualifiedName sets the value of the targetActivity property. +func (o *JumpToActivity) SetTargetActivityQualifiedName(v string) { + o.targetActivity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *JumpToActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if val, err := raw.LookupErr("TargetActivity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.targetActivity.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// Recurrence +// ──────────────────────────────────────────────────────── + +type Recurrence struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Recurrence) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// LinearRecurrence +// ──────────────────────────────────────────────────────── + +type LinearRecurrence struct { + element.Base + intervalType *property.Enum[string] + interval *property.Primitive[int32] + maxExecutions *property.Primitive[int32] +} + +// IntervalType returns the value of the intervalType property. +func (o *LinearRecurrence) IntervalType() string { + return o.intervalType.Get() +} + +// SetIntervalType sets the value of the intervalType property. +func (o *LinearRecurrence) SetIntervalType(v string) { + o.intervalType.Set(v) +} + +// Interval returns the value of the interval property. +func (o *LinearRecurrence) Interval() int32 { + return o.interval.Get() +} + +// SetInterval sets the value of the interval property. +func (o *LinearRecurrence) SetInterval(v int32) { + o.interval.Set(v) +} + +// MaxExecutions returns the value of the maxExecutions property. +func (o *LinearRecurrence) MaxExecutions() int32 { + return o.maxExecutions.Get() +} + +// SetMaxExecutions sets the value of the maxExecutions property. +func (o *LinearRecurrence) SetMaxExecutions(v int32) { + o.maxExecutions.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *LinearRecurrence) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("IntervalType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.intervalType.SetFromDecode(s) } + } + o.interval.Init(raw) + o.maxExecutions.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MajorityCompletionCriteria +// ──────────────────────────────────────────────────────── + +type MajorityCompletionCriteria struct { + element.Base + completionType *property.Enum[string] + fallbackOutcome *property.ByIdRef[element.Element] +} + +// CompletionType returns the value of the completionType property. +func (o *MajorityCompletionCriteria) CompletionType() string { + return o.completionType.Get() +} + +// SetCompletionType sets the value of the completionType property. +func (o *MajorityCompletionCriteria) SetCompletionType(v string) { + o.completionType.Set(v) +} + +// FallbackOutcomeRefID returns the value of the fallbackOutcome property. +func (o *MajorityCompletionCriteria) FallbackOutcomeRefID() element.ID { + return o.fallbackOutcome.RefID() +} + +// SetFallbackOutcomeID sets the value of the fallbackOutcome property. +func (o *MajorityCompletionCriteria) SetFallbackOutcomeID(v element.ID) { + o.fallbackOutcome.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MajorityCompletionCriteria) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("CompletionType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.completionType.SetFromDecode(s) } + } + if val, err := raw.LookupErr("FallbackOutcomePointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.fallbackOutcome.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.fallbackOutcome.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// MergeActivity +// ──────────────────────────────────────────────────────── + +type MergeActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *MergeActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *MergeActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *MergeActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MergeActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *MergeActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *MergeActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *MergeActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *MergeActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *MergeActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *MergeActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *MergeActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *MergeActivity) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MergeActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// UserTaskEvent +// ──────────────────────────────────────────────────────── + +type UserTaskEvent struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserTaskEvent) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// MicroflowBasedEvent +// ──────────────────────────────────────────────────────── + +type MicroflowBasedEvent struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowBasedEvent) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowBasedEvent) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowBasedEvent) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// UserTargeting +// ──────────────────────────────────────────────────────── + +type UserTargeting struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserTargeting) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// MicroflowBasedTargeting +// ──────────────────────────────────────────────────────── + +type MicroflowBasedTargeting struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowBasedTargeting) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowBasedTargeting) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowBasedTargeting) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowBasedUserSource +// ──────────────────────────────────────────────────────── + +type MicroflowBasedUserSource struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowBasedUserSource) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowBasedUserSource) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowBasedUserSource) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowCallParameterMapping +// ──────────────────────────────────────────────────────── + +type MicroflowCallParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + expression *property.Primitive[string] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *MicroflowCallParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *MicroflowCallParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Expression returns the value of the expression property. +func (o *MicroflowCallParameterMapping) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *MicroflowCallParameterMapping) SetExpression(v string) { + o.expression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowCallParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.expression.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MicroflowCompletionCriteria +// ──────────────────────────────────────────────────────── + +type MicroflowCompletionCriteria struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowCompletionCriteria) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowCompletionCriteria) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowCompletionCriteria) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowEventHandler +// ──────────────────────────────────────────────────────── + +type MicroflowEventHandler struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowEventHandler) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowEventHandler) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowEventHandler) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowGroupTargeting +// ──────────────────────────────────────────────────────── + +type MicroflowGroupTargeting struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowGroupTargeting) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowGroupTargeting) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowGroupTargeting) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// MicroflowUserTargeting +// ──────────────────────────────────────────────────────── + +type MicroflowUserTargeting struct { + element.Base + microflow *property.ByNameRef[element.Element] +} + +// MicroflowQualifiedName returns the value of the microflow property. +func (o *MicroflowUserTargeting) MicroflowQualifiedName() string { + return o.microflow.QualifiedName() +} + +// SetMicroflowQualifiedName sets the value of the microflow property. +func (o *MicroflowUserTargeting) SetMicroflowQualifiedName(v string) { + o.microflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MicroflowUserTargeting) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Microflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.microflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// UserTaskCompletion +// ──────────────────────────────────────────────────────── + +type UserTaskCompletion struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserTaskCompletion) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// MultiInputCompletion +// ──────────────────────────────────────────────────────── + +type MultiInputCompletion struct { + element.Base + targetUserInput *property.Part[element.Element] + completionCriteria *property.Part[element.Element] + awaitAllUsers *property.Primitive[bool] +} + +// TargetUserInput returns the value of the targetUserInput property. +func (o *MultiInputCompletion) TargetUserInput() element.Element { + return o.targetUserInput.Get() +} + +// SetTargetUserInput sets the value of the targetUserInput property. +func (o *MultiInputCompletion) SetTargetUserInput(v element.Element) { + o.targetUserInput.Set(v) +} + +// CompletionCriteria returns the value of the completionCriteria property. +func (o *MultiInputCompletion) CompletionCriteria() element.Element { + return o.completionCriteria.Get() +} + +// SetCompletionCriteria sets the value of the completionCriteria property. +func (o *MultiInputCompletion) SetCompletionCriteria(v element.Element) { + o.completionCriteria.Set(v) +} + +// AwaitAllUsers returns the value of the awaitAllUsers property. +func (o *MultiInputCompletion) AwaitAllUsers() bool { + return o.awaitAllUsers.Get() +} + +// SetAwaitAllUsers sets the value of the awaitAllUsers property. +func (o *MultiInputCompletion) SetAwaitAllUsers(v bool) { + o.awaitAllUsers.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MultiInputCompletion) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "TargetUserInput"); err == nil { + o.targetUserInput.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "CompletionCriteria"); err == nil { + o.completionCriteria.SetFromDecode(child) + } + o.awaitAllUsers.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// UserTaskActivity +// ──────────────────────────────────────────────────────── + +type UserTaskActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + taskPage *property.Part[element.Element] + taskName *property.Part[element.Element] + taskDescription *property.Part[element.Element] + dueDate *property.Primitive[string] + userSource *property.Part[element.Element] + userTargeting *property.Part[element.Element] + outcomes *property.PartList[element.Element] + boundaryEvents *property.PartList[element.Element] + onCreatedEvent *property.Part[element.Element] + autoAssignSingleTargetUser *property.Primitive[bool] +} + +// PersistentId returns the value of the persistentId property. +func (o *UserTaskActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *UserTaskActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *UserTaskActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *UserTaskActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *UserTaskActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *UserTaskActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *UserTaskActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *UserTaskActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *UserTaskActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *UserTaskActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *UserTaskActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *UserTaskActivity) SetSize(v string) { + o.size.Set(v) +} + +// TaskPage returns the value of the taskPage property. +func (o *UserTaskActivity) TaskPage() element.Element { + return o.taskPage.Get() +} + +// SetTaskPage sets the value of the taskPage property. +func (o *UserTaskActivity) SetTaskPage(v element.Element) { + o.taskPage.Set(v) +} + +// TaskName returns the value of the taskName property. +func (o *UserTaskActivity) TaskName() element.Element { + return o.taskName.Get() +} + +// SetTaskName sets the value of the taskName property. +func (o *UserTaskActivity) SetTaskName(v element.Element) { + o.taskName.Set(v) +} + +// TaskDescription returns the value of the taskDescription property. +func (o *UserTaskActivity) TaskDescription() element.Element { + return o.taskDescription.Get() +} + +// SetTaskDescription sets the value of the taskDescription property. +func (o *UserTaskActivity) SetTaskDescription(v element.Element) { + o.taskDescription.Set(v) +} + +// DueDate returns the value of the dueDate property. +func (o *UserTaskActivity) DueDate() string { + return o.dueDate.Get() +} + +// SetDueDate sets the value of the dueDate property. +func (o *UserTaskActivity) SetDueDate(v string) { + o.dueDate.Set(v) +} + +// UserSource returns the value of the userSource property. +func (o *UserTaskActivity) UserSource() element.Element { + return o.userSource.Get() +} + +// SetUserSource sets the value of the userSource property. +func (o *UserTaskActivity) SetUserSource(v element.Element) { + o.userSource.Set(v) +} + +// UserTargeting returns the value of the userTargeting property. +func (o *UserTaskActivity) UserTargeting() element.Element { + return o.userTargeting.Get() +} + +// SetUserTargeting sets the value of the userTargeting property. +func (o *UserTaskActivity) SetUserTargeting(v element.Element) { + o.userTargeting.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *UserTaskActivity) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *UserTaskActivity) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *UserTaskActivity) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// BoundaryEventsItems returns the value of the boundaryEvents property. +func (o *UserTaskActivity) BoundaryEventsItems() []element.Element { + return o.boundaryEvents.Items() +} + +// AddBoundaryEvents appends a child element to the boundaryEvents list. +func (o *UserTaskActivity) AddBoundaryEvents(v element.Element) { + o.boundaryEvents.Append(v) +} + +// RemoveBoundaryEvents removes the element at the given index from the boundaryEvents list. +func (o *UserTaskActivity) RemoveBoundaryEvents(index int) { + o.boundaryEvents.Remove(index) +} + +// OnCreatedEvent returns the value of the onCreatedEvent property. +func (o *UserTaskActivity) OnCreatedEvent() element.Element { + return o.onCreatedEvent.Get() +} + +// SetOnCreatedEvent sets the value of the onCreatedEvent property. +func (o *UserTaskActivity) SetOnCreatedEvent(v element.Element) { + o.onCreatedEvent.Set(v) +} + +// AutoAssignSingleTargetUser returns the value of the autoAssignSingleTargetUser property. +func (o *UserTaskActivity) AutoAssignSingleTargetUser() bool { + return o.autoAssignSingleTargetUser.Get() +} + +// SetAutoAssignSingleTargetUser sets the value of the autoAssignSingleTargetUser property. +func (o *UserTaskActivity) SetAutoAssignSingleTargetUser(v bool) { + o.autoAssignSingleTargetUser.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserTaskActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if child, err := codec.DecodeChild(raw, "TaskPage"); err == nil { + o.taskPage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TaskName"); err == nil { + o.taskName.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TaskDescription"); err == nil { + o.taskDescription.SetFromDecode(child) + } + o.dueDate.Init(raw) + if child, err := codec.DecodeChild(raw, "UserSource"); err == nil { + o.userSource.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "UserTargeting"); err == nil { + o.userTargeting.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "BoundaryEvents"); err == nil { + for _, child := range children { + o.boundaryEvents.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "OnCreatedEvent"); err == nil { + o.onCreatedEvent.SetFromDecode(child) + } + o.autoAssignSingleTargetUser.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// MultiUserTaskActivity +// ──────────────────────────────────────────────────────── + +type MultiUserTaskActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + taskPage *property.Part[element.Element] + taskName *property.Part[element.Element] + taskDescription *property.Part[element.Element] + dueDate *property.Primitive[string] + userSource *property.Part[element.Element] + userTargeting *property.Part[element.Element] + outcomes *property.PartList[element.Element] + boundaryEvents *property.PartList[element.Element] + onCreatedEvent *property.Part[element.Element] + autoAssignSingleTargetUser *property.Primitive[bool] + targetUserInput *property.Part[element.Element] + completionCriteria *property.Part[element.Element] + awaitAllUsers *property.Primitive[bool] +} + +// PersistentId returns the value of the persistentId property. +func (o *MultiUserTaskActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *MultiUserTaskActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *MultiUserTaskActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MultiUserTaskActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *MultiUserTaskActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *MultiUserTaskActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *MultiUserTaskActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *MultiUserTaskActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *MultiUserTaskActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *MultiUserTaskActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *MultiUserTaskActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *MultiUserTaskActivity) SetSize(v string) { + o.size.Set(v) +} + +// TaskPage returns the value of the taskPage property. +func (o *MultiUserTaskActivity) TaskPage() element.Element { + return o.taskPage.Get() +} + +// SetTaskPage sets the value of the taskPage property. +func (o *MultiUserTaskActivity) SetTaskPage(v element.Element) { + o.taskPage.Set(v) +} + +// TaskName returns the value of the taskName property. +func (o *MultiUserTaskActivity) TaskName() element.Element { + return o.taskName.Get() +} + +// SetTaskName sets the value of the taskName property. +func (o *MultiUserTaskActivity) SetTaskName(v element.Element) { + o.taskName.Set(v) +} + +// TaskDescription returns the value of the taskDescription property. +func (o *MultiUserTaskActivity) TaskDescription() element.Element { + return o.taskDescription.Get() +} + +// SetTaskDescription sets the value of the taskDescription property. +func (o *MultiUserTaskActivity) SetTaskDescription(v element.Element) { + o.taskDescription.Set(v) +} + +// DueDate returns the value of the dueDate property. +func (o *MultiUserTaskActivity) DueDate() string { + return o.dueDate.Get() +} + +// SetDueDate sets the value of the dueDate property. +func (o *MultiUserTaskActivity) SetDueDate(v string) { + o.dueDate.Set(v) +} + +// UserSource returns the value of the userSource property. +func (o *MultiUserTaskActivity) UserSource() element.Element { + return o.userSource.Get() +} + +// SetUserSource sets the value of the userSource property. +func (o *MultiUserTaskActivity) SetUserSource(v element.Element) { + o.userSource.Set(v) +} + +// UserTargeting returns the value of the userTargeting property. +func (o *MultiUserTaskActivity) UserTargeting() element.Element { + return o.userTargeting.Get() +} + +// SetUserTargeting sets the value of the userTargeting property. +func (o *MultiUserTaskActivity) SetUserTargeting(v element.Element) { + o.userTargeting.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *MultiUserTaskActivity) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *MultiUserTaskActivity) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *MultiUserTaskActivity) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// BoundaryEventsItems returns the value of the boundaryEvents property. +func (o *MultiUserTaskActivity) BoundaryEventsItems() []element.Element { + return o.boundaryEvents.Items() +} + +// AddBoundaryEvents appends a child element to the boundaryEvents list. +func (o *MultiUserTaskActivity) AddBoundaryEvents(v element.Element) { + o.boundaryEvents.Append(v) +} + +// RemoveBoundaryEvents removes the element at the given index from the boundaryEvents list. +func (o *MultiUserTaskActivity) RemoveBoundaryEvents(index int) { + o.boundaryEvents.Remove(index) +} + +// OnCreatedEvent returns the value of the onCreatedEvent property. +func (o *MultiUserTaskActivity) OnCreatedEvent() element.Element { + return o.onCreatedEvent.Get() +} + +// SetOnCreatedEvent sets the value of the onCreatedEvent property. +func (o *MultiUserTaskActivity) SetOnCreatedEvent(v element.Element) { + o.onCreatedEvent.Set(v) +} + +// AutoAssignSingleTargetUser returns the value of the autoAssignSingleTargetUser property. +func (o *MultiUserTaskActivity) AutoAssignSingleTargetUser() bool { + return o.autoAssignSingleTargetUser.Get() +} + +// SetAutoAssignSingleTargetUser sets the value of the autoAssignSingleTargetUser property. +func (o *MultiUserTaskActivity) SetAutoAssignSingleTargetUser(v bool) { + o.autoAssignSingleTargetUser.Set(v) +} + +// TargetUserInput returns the value of the targetUserInput property. +func (o *MultiUserTaskActivity) TargetUserInput() element.Element { + return o.targetUserInput.Get() +} + +// SetTargetUserInput sets the value of the targetUserInput property. +func (o *MultiUserTaskActivity) SetTargetUserInput(v element.Element) { + o.targetUserInput.Set(v) +} + +// CompletionCriteria returns the value of the completionCriteria property. +func (o *MultiUserTaskActivity) CompletionCriteria() element.Element { + return o.completionCriteria.Get() +} + +// SetCompletionCriteria sets the value of the completionCriteria property. +func (o *MultiUserTaskActivity) SetCompletionCriteria(v element.Element) { + o.completionCriteria.Set(v) +} + +// AwaitAllUsers returns the value of the awaitAllUsers property. +func (o *MultiUserTaskActivity) AwaitAllUsers() bool { + return o.awaitAllUsers.Get() +} + +// SetAwaitAllUsers sets the value of the awaitAllUsers property. +func (o *MultiUserTaskActivity) SetAwaitAllUsers(v bool) { + o.awaitAllUsers.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MultiUserTaskActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if child, err := codec.DecodeChild(raw, "TaskPage"); err == nil { + o.taskPage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TaskName"); err == nil { + o.taskName.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TaskDescription"); err == nil { + o.taskDescription.SetFromDecode(child) + } + o.dueDate.Init(raw) + if child, err := codec.DecodeChild(raw, "UserSource"); err == nil { + o.userSource.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "UserTargeting"); err == nil { + o.userTargeting.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "BoundaryEvents"); err == nil { + for _, child := range children { + o.boundaryEvents.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "OnCreatedEvent"); err == nil { + o.onCreatedEvent.SetFromDecode(child) + } + o.autoAssignSingleTargetUser.Init(raw) + if child, err := codec.DecodeChild(raw, "TargetUserInput"); err == nil { + o.targetUserInput.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "CompletionCriteria"); err == nil { + o.completionCriteria.SetFromDecode(child) + } + o.awaitAllUsers.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// NoEvent +// ──────────────────────────────────────────────────────── + +type NoEvent struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NoEvent) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// NoUserTargeting +// ──────────────────────────────────────────────────────── + +type NoUserTargeting struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NoUserTargeting) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// NonInterruptingNotificationEventSubProcessStartActivity +// ──────────────────────────────────────────────────────── + +type NonInterruptingNotificationEventSubProcessStartActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NonInterruptingNotificationEventSubProcessStartActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// NotifyTarget +// ──────────────────────────────────────────────────────── + +type NotifyTarget struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NotifyTarget) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// NonInterruptingNotificationEventSubProcessStartActivityTarget +// ──────────────────────────────────────────────────────── + +type NonInterruptingNotificationEventSubProcessStartActivityTarget struct { + element.Base + activity *property.ByNameRef[element.Element] +} + +// ActivityQualifiedName returns the value of the activity property. +func (o *NonInterruptingNotificationEventSubProcessStartActivityTarget) ActivityQualifiedName() string { + return o.activity.QualifiedName() +} + +// SetActivityQualifiedName sets the value of the activity property. +func (o *NonInterruptingNotificationEventSubProcessStartActivityTarget) SetActivityQualifiedName(v string) { + o.activity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NonInterruptingNotificationEventSubProcessStartActivityTarget) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Activity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.activity.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// NonInterruptingTimerBoundaryEvent +// ──────────────────────────────────────────────────────── + +type NonInterruptingTimerBoundaryEvent struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + isInterrupting *property.Primitive[bool] + eventType *property.Primitive[string] + delay *property.Primitive[string] + firstExecutionTime *property.Primitive[string] + recurrence *property.Part[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *NonInterruptingTimerBoundaryEvent) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *NonInterruptingTimerBoundaryEvent) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *NonInterruptingTimerBoundaryEvent) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *NonInterruptingTimerBoundaryEvent) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// Caption returns the value of the caption property. +func (o *NonInterruptingTimerBoundaryEvent) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *NonInterruptingTimerBoundaryEvent) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *NonInterruptingTimerBoundaryEvent) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *NonInterruptingTimerBoundaryEvent) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// IsInterrupting returns the value of the isInterrupting property. +func (o *NonInterruptingTimerBoundaryEvent) IsInterrupting() bool { + return o.isInterrupting.Get() +} + +// SetIsInterrupting sets the value of the isInterrupting property. +func (o *NonInterruptingTimerBoundaryEvent) SetIsInterrupting(v bool) { + o.isInterrupting.Set(v) +} + +// EventType returns the value of the eventType property. +func (o *NonInterruptingTimerBoundaryEvent) EventType() string { + return o.eventType.Get() +} + +// SetEventType sets the value of the eventType property. +func (o *NonInterruptingTimerBoundaryEvent) SetEventType(v string) { + o.eventType.Set(v) +} + +// Delay returns the value of the delay property. +func (o *NonInterruptingTimerBoundaryEvent) Delay() string { + return o.delay.Get() +} + +// SetDelay sets the value of the delay property. +func (o *NonInterruptingTimerBoundaryEvent) SetDelay(v string) { + o.delay.Set(v) +} + +// FirstExecutionTime returns the value of the firstExecutionTime property. +func (o *NonInterruptingTimerBoundaryEvent) FirstExecutionTime() string { + return o.firstExecutionTime.Get() +} + +// SetFirstExecutionTime sets the value of the firstExecutionTime property. +func (o *NonInterruptingTimerBoundaryEvent) SetFirstExecutionTime(v string) { + o.firstExecutionTime.Set(v) +} + +// Recurrence returns the value of the recurrence property. +func (o *NonInterruptingTimerBoundaryEvent) Recurrence() element.Element { + return o.recurrence.Get() +} + +// SetRecurrence sets the value of the recurrence property. +func (o *NonInterruptingTimerBoundaryEvent) SetRecurrence(v element.Element) { + o.recurrence.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NonInterruptingTimerBoundaryEvent) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.isInterrupting.Init(raw) + o.eventType.Init(raw) + o.delay.Init(raw) + o.firstExecutionTime.Init(raw) + if child, err := codec.DecodeChild(raw, "Recurrence"); err == nil { + o.recurrence.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// NotifyWaitForNotificationActivityTarget +// ──────────────────────────────────────────────────────── + +type NotifyWaitForNotificationActivityTarget struct { + element.Base + activity *property.ByNameRef[element.Element] +} + +// ActivityQualifiedName returns the value of the activity property. +func (o *NotifyWaitForNotificationActivityTarget) ActivityQualifiedName() string { + return o.activity.QualifiedName() +} + +// SetActivityQualifiedName sets the value of the activity property. +func (o *NotifyWaitForNotificationActivityTarget) SetActivityQualifiedName(v string) { + o.activity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *NotifyWaitForNotificationActivityTarget) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Activity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.activity.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// OrthogonalPath +// ──────────────────────────────────────────────────────── + +type OrthogonalPath struct { + element.Base + segmentPositions *property.Primitive[string] +} + +// SegmentPositions returns the value of the segmentPositions property. +func (o *OrthogonalPath) SegmentPositions() string { + return o.segmentPositions.Get() +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *OrthogonalPath) InitFromRaw(raw bson.Raw) { + o.segmentPositions.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PageParameterMapping +// ──────────────────────────────────────────────────────── + +type PageParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + expression *property.Primitive[string] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *PageParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *PageParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Expression returns the value of the expression property. +func (o *PageParameterMapping) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *PageParameterMapping) SetExpression(v string) { + o.expression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PageParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.expression.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PageReference +// ──────────────────────────────────────────────────────── + +type PageReference struct { + element.Base + page *property.ByNameRef[element.Element] +} + +// PageQualifiedName returns the value of the page property. +func (o *PageReference) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *PageReference) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PageReference) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Page"); err == nil { + if s, ok := val.StringValueOK(); ok { o.page.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// ParallelSplitActivity +// ──────────────────────────────────────────────────────── + +type ParallelSplitActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + outcomes *property.PartList[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *ParallelSplitActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *ParallelSplitActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *ParallelSplitActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ParallelSplitActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ParallelSplitActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ParallelSplitActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *ParallelSplitActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *ParallelSplitActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *ParallelSplitActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *ParallelSplitActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *ParallelSplitActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *ParallelSplitActivity) SetSize(v string) { + o.size.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *ParallelSplitActivity) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *ParallelSplitActivity) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *ParallelSplitActivity) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ParallelSplitActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// ParallelSplitOutcome +// ──────────────────────────────────────────────────────── + +type ParallelSplitOutcome struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *ParallelSplitOutcome) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *ParallelSplitOutcome) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *ParallelSplitOutcome) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *ParallelSplitOutcome) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ParallelSplitOutcome) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Parameter +// ──────────────────────────────────────────────────────── + +type Parameter struct { + element.Base + entityRef *property.Part[element.Element] + entity *property.ByNameRef[element.Element] + name *property.Primitive[string] +} + +// EntityRef returns the value of the entityRef property. +func (o *Parameter) EntityRef() element.Element { + return o.entityRef.Get() +} + +// SetEntityRef sets the value of the entityRef property. +func (o *Parameter) SetEntityRef(v element.Element) { + o.entityRef.Set(v) +} + +// EntityQualifiedName returns the value of the entity property. +func (o *Parameter) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *Parameter) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// Name returns the value of the name property. +func (o *Parameter) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Parameter) SetName(v string) { + o.name.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Parameter) InitFromRaw(raw bson.Raw) { + if child, err := codec.DecodeChild(raw, "EntityRef"); err == nil { + o.entityRef.SetFromDecode(child) + } + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } + o.name.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// PercentageAmountUserInput +// ──────────────────────────────────────────────────────── + +type PercentageAmountUserInput struct { + element.Base + percentage *property.Primitive[int32] +} + +// Percentage returns the value of the percentage property. +func (o *PercentageAmountUserInput) Percentage() int32 { + return o.percentage.Get() +} + +// SetPercentage sets the value of the percentage property. +func (o *PercentageAmountUserInput) SetPercentage(v int32) { + o.percentage.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *PercentageAmountUserInput) InitFromRaw(raw bson.Raw) { + o.percentage.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// SingleInputCompletion +// ──────────────────────────────────────────────────────── + +type SingleInputCompletion struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SingleInputCompletion) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// SingleUserTaskActivity +// ──────────────────────────────────────────────────────── + +type SingleUserTaskActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + taskPage *property.Part[element.Element] + taskName *property.Part[element.Element] + taskDescription *property.Part[element.Element] + dueDate *property.Primitive[string] + userSource *property.Part[element.Element] + userTargeting *property.Part[element.Element] + outcomes *property.PartList[element.Element] + boundaryEvents *property.PartList[element.Element] + onCreatedEvent *property.Part[element.Element] + autoAssignSingleTargetUser *property.Primitive[bool] +} + +// PersistentId returns the value of the persistentId property. +func (o *SingleUserTaskActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *SingleUserTaskActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *SingleUserTaskActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *SingleUserTaskActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *SingleUserTaskActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *SingleUserTaskActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *SingleUserTaskActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *SingleUserTaskActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *SingleUserTaskActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *SingleUserTaskActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *SingleUserTaskActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *SingleUserTaskActivity) SetSize(v string) { + o.size.Set(v) +} + +// TaskPage returns the value of the taskPage property. +func (o *SingleUserTaskActivity) TaskPage() element.Element { + return o.taskPage.Get() +} + +// SetTaskPage sets the value of the taskPage property. +func (o *SingleUserTaskActivity) SetTaskPage(v element.Element) { + o.taskPage.Set(v) +} + +// TaskName returns the value of the taskName property. +func (o *SingleUserTaskActivity) TaskName() element.Element { + return o.taskName.Get() +} + +// SetTaskName sets the value of the taskName property. +func (o *SingleUserTaskActivity) SetTaskName(v element.Element) { + o.taskName.Set(v) +} + +// TaskDescription returns the value of the taskDescription property. +func (o *SingleUserTaskActivity) TaskDescription() element.Element { + return o.taskDescription.Get() +} + +// SetTaskDescription sets the value of the taskDescription property. +func (o *SingleUserTaskActivity) SetTaskDescription(v element.Element) { + o.taskDescription.Set(v) +} + +// DueDate returns the value of the dueDate property. +func (o *SingleUserTaskActivity) DueDate() string { + return o.dueDate.Get() +} + +// SetDueDate sets the value of the dueDate property. +func (o *SingleUserTaskActivity) SetDueDate(v string) { + o.dueDate.Set(v) +} + +// UserSource returns the value of the userSource property. +func (o *SingleUserTaskActivity) UserSource() element.Element { + return o.userSource.Get() +} + +// SetUserSource sets the value of the userSource property. +func (o *SingleUserTaskActivity) SetUserSource(v element.Element) { + o.userSource.Set(v) +} + +// UserTargeting returns the value of the userTargeting property. +func (o *SingleUserTaskActivity) UserTargeting() element.Element { + return o.userTargeting.Get() +} + +// SetUserTargeting sets the value of the userTargeting property. +func (o *SingleUserTaskActivity) SetUserTargeting(v element.Element) { + o.userTargeting.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *SingleUserTaskActivity) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *SingleUserTaskActivity) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *SingleUserTaskActivity) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// BoundaryEventsItems returns the value of the boundaryEvents property. +func (o *SingleUserTaskActivity) BoundaryEventsItems() []element.Element { + return o.boundaryEvents.Items() +} + +// AddBoundaryEvents appends a child element to the boundaryEvents list. +func (o *SingleUserTaskActivity) AddBoundaryEvents(v element.Element) { + o.boundaryEvents.Append(v) +} + +// RemoveBoundaryEvents removes the element at the given index from the boundaryEvents list. +func (o *SingleUserTaskActivity) RemoveBoundaryEvents(index int) { + o.boundaryEvents.Remove(index) +} + +// OnCreatedEvent returns the value of the onCreatedEvent property. +func (o *SingleUserTaskActivity) OnCreatedEvent() element.Element { + return o.onCreatedEvent.Get() +} + +// SetOnCreatedEvent sets the value of the onCreatedEvent property. +func (o *SingleUserTaskActivity) SetOnCreatedEvent(v element.Element) { + o.onCreatedEvent.Set(v) +} + +// AutoAssignSingleTargetUser returns the value of the autoAssignSingleTargetUser property. +func (o *SingleUserTaskActivity) AutoAssignSingleTargetUser() bool { + return o.autoAssignSingleTargetUser.Get() +} + +// SetAutoAssignSingleTargetUser sets the value of the autoAssignSingleTargetUser property. +func (o *SingleUserTaskActivity) SetAutoAssignSingleTargetUser(v bool) { + o.autoAssignSingleTargetUser.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *SingleUserTaskActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if child, err := codec.DecodeChild(raw, "TaskPage"); err == nil { + o.taskPage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TaskName"); err == nil { + o.taskName.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TaskDescription"); err == nil { + o.taskDescription.SetFromDecode(child) + } + o.dueDate.Init(raw) + if child, err := codec.DecodeChild(raw, "UserSource"); err == nil { + o.userSource.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "UserTargeting"); err == nil { + o.userTargeting.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "BoundaryEvents"); err == nil { + for _, child := range children { + o.boundaryEvents.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "OnCreatedEvent"); err == nil { + o.onCreatedEvent.SetFromDecode(child) + } + o.autoAssignSingleTargetUser.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// StartWorkflowActivity +// ──────────────────────────────────────────────────────── + +type StartWorkflowActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *StartWorkflowActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *StartWorkflowActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *StartWorkflowActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *StartWorkflowActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *StartWorkflowActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *StartWorkflowActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *StartWorkflowActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *StartWorkflowActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *StartWorkflowActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *StartWorkflowActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *StartWorkflowActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *StartWorkflowActivity) SetSize(v string) { + o.size.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StartWorkflowActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// StringCase +// ──────────────────────────────────────────────────────── + +type StringCase struct { + element.Base + value *property.Primitive[string] +} + +// Value returns the value of the value property. +func (o *StringCase) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *StringCase) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *StringCase) InitFromRaw(raw bson.Raw) { + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ThresholdCompletionCriteria +// ──────────────────────────────────────────────────────── + +type ThresholdCompletionCriteria struct { + element.Base + completionType *property.Enum[string] + threshold *property.Primitive[int32] + fallbackOutcome *property.ByIdRef[element.Element] +} + +// CompletionType returns the value of the completionType property. +func (o *ThresholdCompletionCriteria) CompletionType() string { + return o.completionType.Get() +} + +// SetCompletionType sets the value of the completionType property. +func (o *ThresholdCompletionCriteria) SetCompletionType(v string) { + o.completionType.Set(v) +} + +// Threshold returns the value of the threshold property. +func (o *ThresholdCompletionCriteria) Threshold() int32 { + return o.threshold.Get() +} + +// SetThreshold sets the value of the threshold property. +func (o *ThresholdCompletionCriteria) SetThreshold(v int32) { + o.threshold.Set(v) +} + +// FallbackOutcomeRefID returns the value of the fallbackOutcome property. +func (o *ThresholdCompletionCriteria) FallbackOutcomeRefID() element.ID { + return o.fallbackOutcome.RefID() +} + +// SetFallbackOutcomeID sets the value of the fallbackOutcome property. +func (o *ThresholdCompletionCriteria) SetFallbackOutcomeID(v element.ID) { + o.fallbackOutcome.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ThresholdCompletionCriteria) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("CompletionType"); err == nil { + if s, ok := val.StringValueOK(); ok { o.completionType.SetFromDecode(s) } + } + o.threshold.Init(raw) + if val, err := raw.LookupErr("FallbackOutcomePointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.fallbackOutcome.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.fallbackOutcome.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// TimerBoundaryEvent +// ──────────────────────────────────────────────────────── + +type TimerBoundaryEvent struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + isInterrupting *property.Primitive[bool] + eventType *property.Primitive[string] + delay *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *TimerBoundaryEvent) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *TimerBoundaryEvent) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *TimerBoundaryEvent) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *TimerBoundaryEvent) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// Caption returns the value of the caption property. +func (o *TimerBoundaryEvent) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *TimerBoundaryEvent) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *TimerBoundaryEvent) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *TimerBoundaryEvent) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// IsInterrupting returns the value of the isInterrupting property. +func (o *TimerBoundaryEvent) IsInterrupting() bool { + return o.isInterrupting.Get() +} + +// SetIsInterrupting sets the value of the isInterrupting property. +func (o *TimerBoundaryEvent) SetIsInterrupting(v bool) { + o.isInterrupting.Set(v) +} + +// EventType returns the value of the eventType property. +func (o *TimerBoundaryEvent) EventType() string { + return o.eventType.Get() +} + +// SetEventType sets the value of the eventType property. +func (o *TimerBoundaryEvent) SetEventType(v string) { + o.eventType.Set(v) +} + +// Delay returns the value of the delay property. +func (o *TimerBoundaryEvent) Delay() string { + return o.delay.Get() +} + +// SetDelay sets the value of the delay property. +func (o *TimerBoundaryEvent) SetDelay(v string) { + o.delay.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *TimerBoundaryEvent) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.isInterrupting.Init(raw) + o.eventType.Init(raw) + o.delay.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// UserTask +// ──────────────────────────────────────────────────────── + +type UserTask struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + userTaskEntity *property.ByNameRef[element.Element] + page *property.ByNameRef[element.Element] + taskPage *property.Part[element.Element] + taskName *property.Part[element.Element] + taskDescription *property.Part[element.Element] + dueDate *property.Primitive[string] + userSource *property.Part[element.Element] + outcomes *property.PartList[element.Element] + allowedModuleRoles *property.ByNameRefList[element.Element] + onCreatedEvent *property.Part[element.Element] + autoAssignSingleTargetUser *property.Primitive[bool] + userTaskCompletion *property.Part[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *UserTask) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *UserTask) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *UserTask) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *UserTask) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *UserTask) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *UserTask) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *UserTask) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *UserTask) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *UserTask) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *UserTask) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *UserTask) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *UserTask) SetSize(v string) { + o.size.Set(v) +} + +// UserTaskEntityQualifiedName returns the value of the userTaskEntity property. +func (o *UserTask) UserTaskEntityQualifiedName() string { + return o.userTaskEntity.QualifiedName() +} + +// SetUserTaskEntityQualifiedName sets the value of the userTaskEntity property. +func (o *UserTask) SetUserTaskEntityQualifiedName(v string) { + o.userTaskEntity.SetQualifiedName(v) +} + +// PageQualifiedName returns the value of the page property. +func (o *UserTask) PageQualifiedName() string { + return o.page.QualifiedName() +} + +// SetPageQualifiedName sets the value of the page property. +func (o *UserTask) SetPageQualifiedName(v string) { + o.page.SetQualifiedName(v) +} + +// TaskPage returns the value of the taskPage property. +func (o *UserTask) TaskPage() element.Element { + return o.taskPage.Get() +} + +// SetTaskPage sets the value of the taskPage property. +func (o *UserTask) SetTaskPage(v element.Element) { + o.taskPage.Set(v) +} + +// TaskName returns the value of the taskName property. +func (o *UserTask) TaskName() element.Element { + return o.taskName.Get() +} + +// SetTaskName sets the value of the taskName property. +func (o *UserTask) SetTaskName(v element.Element) { + o.taskName.Set(v) +} + +// TaskDescription returns the value of the taskDescription property. +func (o *UserTask) TaskDescription() element.Element { + return o.taskDescription.Get() +} + +// SetTaskDescription sets the value of the taskDescription property. +func (o *UserTask) SetTaskDescription(v element.Element) { + o.taskDescription.Set(v) +} + +// DueDate returns the value of the dueDate property. +func (o *UserTask) DueDate() string { + return o.dueDate.Get() +} + +// SetDueDate sets the value of the dueDate property. +func (o *UserTask) SetDueDate(v string) { + o.dueDate.Set(v) +} + +// UserSource returns the value of the userSource property. +func (o *UserTask) UserSource() element.Element { + return o.userSource.Get() +} + +// SetUserSource sets the value of the userSource property. +func (o *UserTask) SetUserSource(v element.Element) { + o.userSource.Set(v) +} + +// OutcomesItems returns the value of the outcomes property. +func (o *UserTask) OutcomesItems() []element.Element { + return o.outcomes.Items() +} + +// AddOutcomes appends a child element to the outcomes list. +func (o *UserTask) AddOutcomes(v element.Element) { + o.outcomes.Append(v) +} + +// RemoveOutcomes removes the element at the given index from the outcomes list. +func (o *UserTask) RemoveOutcomes(index int) { + o.outcomes.Remove(index) +} + +// AllowedModuleRolesQualifiedNames returns the value of the allowedModuleRoles property. +func (o *UserTask) AllowedModuleRolesQualifiedNames() []string { + return o.allowedModuleRoles.QualifiedNames() +} + +// SetAllowedModuleRolesQualifiedNames sets the value of the allowedModuleRoles property. +func (o *UserTask) SetAllowedModuleRolesQualifiedNames(v []string) { + o.allowedModuleRoles.SetQualifiedNames(v) +} + +// AddAllowedModuleRoles appends a child element to the allowedModuleRoles list. +func (o *UserTask) AddAllowedModuleRoles(v string) { + o.allowedModuleRoles.Append(v) +} + +// OnCreatedEvent returns the value of the onCreatedEvent property. +func (o *UserTask) OnCreatedEvent() element.Element { + return o.onCreatedEvent.Get() +} + +// SetOnCreatedEvent sets the value of the onCreatedEvent property. +func (o *UserTask) SetOnCreatedEvent(v element.Element) { + o.onCreatedEvent.Set(v) +} + +// AutoAssignSingleTargetUser returns the value of the autoAssignSingleTargetUser property. +func (o *UserTask) AutoAssignSingleTargetUser() bool { + return o.autoAssignSingleTargetUser.Get() +} + +// SetAutoAssignSingleTargetUser sets the value of the autoAssignSingleTargetUser property. +func (o *UserTask) SetAutoAssignSingleTargetUser(v bool) { + o.autoAssignSingleTargetUser.Set(v) +} + +// UserTaskCompletion returns the value of the userTaskCompletion property. +func (o *UserTask) UserTaskCompletion() element.Element { + return o.userTaskCompletion.Get() +} + +// SetUserTaskCompletion sets the value of the userTaskCompletion property. +func (o *UserTask) SetUserTaskCompletion(v element.Element) { + o.userTaskCompletion.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserTask) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if val, err := raw.LookupErr("UserTaskEntity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.userTaskEntity.SetFromDecode(s) } + } + if val, err := raw.LookupErr("Page"); err == nil { + if s, ok := val.StringValueOK(); ok { o.page.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "TaskPage"); err == nil { + o.taskPage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TaskName"); err == nil { + o.taskName.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "TaskDescription"); err == nil { + o.taskDescription.SetFromDecode(child) + } + o.dueDate.Init(raw) + if child, err := codec.DecodeChild(raw, "UserSource"); err == nil { + o.userSource.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "Outcomes"); err == nil { + for _, child := range children { + o.outcomes.AppendFromDecode(child) + } + } + if val, err := raw.LookupErr("AllowedModuleRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.allowedModuleRoles.SetFromDecode(qnames) + } + } + if child, err := codec.DecodeChild(raw, "OnCreatedEvent"); err == nil { + o.onCreatedEvent.SetFromDecode(child) + } + o.autoAssignSingleTargetUser.Init(raw) + if child, err := codec.DecodeChild(raw, "UserTaskCompletion"); err == nil { + o.userTaskCompletion.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// UserTaskOutcome +// ──────────────────────────────────────────────────────── + +type UserTaskOutcome struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] + name *property.Primitive[string] + caption *property.Primitive[string] + value *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *UserTaskOutcome) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *UserTaskOutcome) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *UserTaskOutcome) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *UserTaskOutcome) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// Name returns the value of the name property. +func (o *UserTaskOutcome) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *UserTaskOutcome) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *UserTaskOutcome) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *UserTaskOutcome) SetCaption(v string) { + o.caption.Set(v) +} + +// Value returns the value of the value property. +func (o *UserTaskOutcome) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *UserTaskOutcome) SetValue(v string) { + o.value.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *UserTaskOutcome) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } + o.name.Init(raw) + o.caption.Init(raw) + o.value.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// VetoCompletionCriteria +// ──────────────────────────────────────────────────────── + +type VetoCompletionCriteria struct { + element.Base + vetoOutcome *property.ByIdRef[element.Element] +} + +// VetoOutcomeRefID returns the value of the vetoOutcome property. +func (o *VetoCompletionCriteria) VetoOutcomeRefID() element.ID { + return o.vetoOutcome.RefID() +} + +// SetVetoOutcomeID sets the value of the vetoOutcome property. +func (o *VetoCompletionCriteria) SetVetoOutcomeID(v element.ID) { + o.vetoOutcome.SetID(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VetoCompletionCriteria) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("VetoOutcomePointer"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.vetoOutcome.SetFromDecode(element.ID(s)) + } else if _, bdata, bok := val.BinaryOK(); bok { + o.vetoOutcome.SetFromDecode(element.ID(codec.BinaryToUUID(bdata))) + } + } +} + +// ──────────────────────────────────────────────────────── +// VoidCase +// ──────────────────────────────────────────────────────── + +type VoidCase struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VoidCase) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// VoidConditionOutcome +// ──────────────────────────────────────────────────────── + +type VoidConditionOutcome struct { + element.Base + persistentId *property.Primitive[string] + flow *property.Part[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *VoidConditionOutcome) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *VoidConditionOutcome) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Flow returns the value of the flow property. +func (o *VoidConditionOutcome) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *VoidConditionOutcome) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *VoidConditionOutcome) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// WaitForNotificationActivity +// ──────────────────────────────────────────────────────── + +type WaitForNotificationActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + boundaryEvents *property.PartList[element.Element] +} + +// PersistentId returns the value of the persistentId property. +func (o *WaitForNotificationActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *WaitForNotificationActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *WaitForNotificationActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *WaitForNotificationActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *WaitForNotificationActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *WaitForNotificationActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *WaitForNotificationActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *WaitForNotificationActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *WaitForNotificationActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *WaitForNotificationActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *WaitForNotificationActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *WaitForNotificationActivity) SetSize(v string) { + o.size.Set(v) +} + +// BoundaryEventsItems returns the value of the boundaryEvents property. +func (o *WaitForNotificationActivity) BoundaryEventsItems() []element.Element { + return o.boundaryEvents.Items() +} + +// AddBoundaryEvents appends a child element to the boundaryEvents list. +func (o *WaitForNotificationActivity) AddBoundaryEvents(v element.Element) { + o.boundaryEvents.Append(v) +} + +// RemoveBoundaryEvents removes the element at the given index from the boundaryEvents list. +func (o *WaitForNotificationActivity) RemoveBoundaryEvents(index int) { + o.boundaryEvents.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WaitForNotificationActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + if children, err := codec.DecodeChildren(raw, "BoundaryEvents"); err == nil { + for _, child := range children { + o.boundaryEvents.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// WaitForTimerActivity +// ──────────────────────────────────────────────────────── + +type WaitForTimerActivity struct { + element.Base + persistentId *property.Primitive[string] + name *property.Primitive[string] + caption *property.Primitive[string] + annotation *property.Part[element.Element] + relativeMiddlePoint *property.Primitive[string] + size *property.Primitive[string] + delay *property.Primitive[string] +} + +// PersistentId returns the value of the persistentId property. +func (o *WaitForTimerActivity) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *WaitForTimerActivity) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Name returns the value of the name property. +func (o *WaitForTimerActivity) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *WaitForTimerActivity) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *WaitForTimerActivity) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *WaitForTimerActivity) SetCaption(v string) { + o.caption.Set(v) +} + +// Annotation returns the value of the annotation property. +func (o *WaitForTimerActivity) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *WaitForTimerActivity) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// RelativeMiddlePoint returns the value of the relativeMiddlePoint property. +func (o *WaitForTimerActivity) RelativeMiddlePoint() string { + return o.relativeMiddlePoint.Get() +} + +// SetRelativeMiddlePoint sets the value of the relativeMiddlePoint property. +func (o *WaitForTimerActivity) SetRelativeMiddlePoint(v string) { + o.relativeMiddlePoint.Set(v) +} + +// Size returns the value of the size property. +func (o *WaitForTimerActivity) Size() string { + return o.size.Get() +} + +// SetSize sets the value of the size property. +func (o *WaitForTimerActivity) SetSize(v string) { + o.size.Set(v) +} + +// Delay returns the value of the delay property. +func (o *WaitForTimerActivity) Delay() string { + return o.delay.Get() +} + +// SetDelay sets the value of the delay property. +func (o *WaitForTimerActivity) SetDelay(v string) { + o.delay.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WaitForTimerActivity) InitFromRaw(raw bson.Raw) { + o.persistentId.Init(raw) + o.name.Init(raw) + o.caption.Init(raw) + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + o.relativeMiddlePoint.Init(raw) + o.size.Init(raw) + o.delay.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Workflow +// ──────────────────────────────────────────────────────── + +type Workflow struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + persistentId *property.Primitive[string] + title *property.Primitive[string] + contextEntity *property.ByNameRef[element.Element] + parameter *property.Part[element.Element] + workflowEntity *property.ByNameRef[element.Element] + workflowType *property.Part[element.Element] + overviewPage *property.ByNameRef[element.Element] + adminPage *property.Part[element.Element] + flow *property.Part[element.Element] + workflowName *property.Part[element.Element] + workflowDescription *property.Part[element.Element] + dueDate *property.Primitive[string] + allowedModuleRoles *property.ByNameRefList[element.Element] + workflowOnStateChangeEvent *property.Part[element.Element] + usertaskOnStateChangeEvent *property.Part[element.Element] + onWorkflowEvent *property.PartList[element.Element] + eventSubProcesses *property.PartList[element.Element] + annotation *property.Part[element.Element] + workflowMetaData *property.Part[element.Element] + workflowV2 *property.Primitive[bool] +} + +// Name returns the value of the name property. +func (o *Workflow) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *Workflow) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *Workflow) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *Workflow) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *Workflow) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *Workflow) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *Workflow) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *Workflow) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// PersistentId returns the value of the persistentId property. +func (o *Workflow) PersistentId() string { + return o.persistentId.Get() +} + +// SetPersistentId sets the value of the persistentId property. +func (o *Workflow) SetPersistentId(v string) { + o.persistentId.Set(v) +} + +// Title returns the value of the title property. +func (o *Workflow) Title() string { + return o.title.Get() +} + +// SetTitle sets the value of the title property. +func (o *Workflow) SetTitle(v string) { + o.title.Set(v) +} + +// ContextEntityQualifiedName returns the value of the contextEntity property. +func (o *Workflow) ContextEntityQualifiedName() string { + return o.contextEntity.QualifiedName() +} + +// SetContextEntityQualifiedName sets the value of the contextEntity property. +func (o *Workflow) SetContextEntityQualifiedName(v string) { + o.contextEntity.SetQualifiedName(v) +} + +// Parameter returns the value of the parameter property. +func (o *Workflow) Parameter() element.Element { + return o.parameter.Get() +} + +// SetParameter sets the value of the parameter property. +func (o *Workflow) SetParameter(v element.Element) { + o.parameter.Set(v) +} + +// WorkflowEntityQualifiedName returns the value of the workflowEntity property. +func (o *Workflow) WorkflowEntityQualifiedName() string { + return o.workflowEntity.QualifiedName() +} + +// SetWorkflowEntityQualifiedName sets the value of the workflowEntity property. +func (o *Workflow) SetWorkflowEntityQualifiedName(v string) { + o.workflowEntity.SetQualifiedName(v) +} + +// WorkflowType returns the value of the workflowType property. +func (o *Workflow) WorkflowType() element.Element { + return o.workflowType.Get() +} + +// SetWorkflowType sets the value of the workflowType property. +func (o *Workflow) SetWorkflowType(v element.Element) { + o.workflowType.Set(v) +} + +// OverviewPageQualifiedName returns the value of the overviewPage property. +func (o *Workflow) OverviewPageQualifiedName() string { + return o.overviewPage.QualifiedName() +} + +// SetOverviewPageQualifiedName sets the value of the overviewPage property. +func (o *Workflow) SetOverviewPageQualifiedName(v string) { + o.overviewPage.SetQualifiedName(v) +} + +// AdminPage returns the value of the adminPage property. +func (o *Workflow) AdminPage() element.Element { + return o.adminPage.Get() +} + +// SetAdminPage sets the value of the adminPage property. +func (o *Workflow) SetAdminPage(v element.Element) { + o.adminPage.Set(v) +} + +// Flow returns the value of the flow property. +func (o *Workflow) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *Workflow) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// WorkflowName returns the value of the workflowName property. +func (o *Workflow) WorkflowName() element.Element { + return o.workflowName.Get() +} + +// SetWorkflowName sets the value of the workflowName property. +func (o *Workflow) SetWorkflowName(v element.Element) { + o.workflowName.Set(v) +} + +// WorkflowDescription returns the value of the workflowDescription property. +func (o *Workflow) WorkflowDescription() element.Element { + return o.workflowDescription.Get() +} + +// SetWorkflowDescription sets the value of the workflowDescription property. +func (o *Workflow) SetWorkflowDescription(v element.Element) { + o.workflowDescription.Set(v) +} + +// DueDate returns the value of the dueDate property. +func (o *Workflow) DueDate() string { + return o.dueDate.Get() +} + +// SetDueDate sets the value of the dueDate property. +func (o *Workflow) SetDueDate(v string) { + o.dueDate.Set(v) +} + +// AllowedModuleRolesQualifiedNames returns the value of the allowedModuleRoles property. +func (o *Workflow) AllowedModuleRolesQualifiedNames() []string { + return o.allowedModuleRoles.QualifiedNames() +} + +// SetAllowedModuleRolesQualifiedNames sets the value of the allowedModuleRoles property. +func (o *Workflow) SetAllowedModuleRolesQualifiedNames(v []string) { + o.allowedModuleRoles.SetQualifiedNames(v) +} + +// AddAllowedModuleRoles appends a child element to the allowedModuleRoles list. +func (o *Workflow) AddAllowedModuleRoles(v string) { + o.allowedModuleRoles.Append(v) +} + +// WorkflowOnStateChangeEvent returns the value of the workflowOnStateChangeEvent property. +func (o *Workflow) WorkflowOnStateChangeEvent() element.Element { + return o.workflowOnStateChangeEvent.Get() +} + +// SetWorkflowOnStateChangeEvent sets the value of the workflowOnStateChangeEvent property. +func (o *Workflow) SetWorkflowOnStateChangeEvent(v element.Element) { + o.workflowOnStateChangeEvent.Set(v) +} + +// UsertaskOnStateChangeEvent returns the value of the usertaskOnStateChangeEvent property. +func (o *Workflow) UsertaskOnStateChangeEvent() element.Element { + return o.usertaskOnStateChangeEvent.Get() +} + +// SetUsertaskOnStateChangeEvent sets the value of the usertaskOnStateChangeEvent property. +func (o *Workflow) SetUsertaskOnStateChangeEvent(v element.Element) { + o.usertaskOnStateChangeEvent.Set(v) +} + +// OnWorkflowEventItems returns the value of the onWorkflowEvent property. +func (o *Workflow) OnWorkflowEventItems() []element.Element { + return o.onWorkflowEvent.Items() +} + +// AddOnWorkflowEvent appends a child element to the onWorkflowEvent list. +func (o *Workflow) AddOnWorkflowEvent(v element.Element) { + o.onWorkflowEvent.Append(v) +} + +// RemoveOnWorkflowEvent removes the element at the given index from the onWorkflowEvent list. +func (o *Workflow) RemoveOnWorkflowEvent(index int) { + o.onWorkflowEvent.Remove(index) +} + +// EventSubProcessesItems returns the value of the eventSubProcesses property. +func (o *Workflow) EventSubProcessesItems() []element.Element { + return o.eventSubProcesses.Items() +} + +// AddEventSubProcesses appends a child element to the eventSubProcesses list. +func (o *Workflow) AddEventSubProcesses(v element.Element) { + o.eventSubProcesses.Append(v) +} + +// RemoveEventSubProcesses removes the element at the given index from the eventSubProcesses list. +func (o *Workflow) RemoveEventSubProcesses(index int) { + o.eventSubProcesses.Remove(index) +} + +// Annotation returns the value of the annotation property. +func (o *Workflow) Annotation() element.Element { + return o.annotation.Get() +} + +// SetAnnotation sets the value of the annotation property. +func (o *Workflow) SetAnnotation(v element.Element) { + o.annotation.Set(v) +} + +// WorkflowMetaData returns the value of the workflowMetaData property. +func (o *Workflow) WorkflowMetaData() element.Element { + return o.workflowMetaData.Get() +} + +// SetWorkflowMetaData sets the value of the workflowMetaData property. +func (o *Workflow) SetWorkflowMetaData(v element.Element) { + o.workflowMetaData.Set(v) +} + +// WorkflowV2 returns the value of the workflowV2 property. +func (o *Workflow) WorkflowV2() bool { + return o.workflowV2.Get() +} + +// SetWorkflowV2 sets the value of the workflowV2 property. +func (o *Workflow) SetWorkflowV2(v bool) { + o.workflowV2.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *Workflow) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { o.exportLevel.SetFromDecode(s) } + } + o.persistentId.Init(raw) + o.title.Init(raw) + if val, err := raw.LookupErr("ContextEntity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.contextEntity.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "Parameter"); err == nil { + o.parameter.SetFromDecode(child) + } + if val, err := raw.LookupErr("WorkflowEntity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.workflowEntity.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "WorkflowType"); err == nil { + o.workflowType.SetFromDecode(child) + } + if val, err := raw.LookupErr("OverviewPage"); err == nil { + if s, ok := val.StringValueOK(); ok { o.overviewPage.SetFromDecode(s) } + } + if child, err := codec.DecodeChild(raw, "AdminPage"); err == nil { + o.adminPage.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "WorkflowName"); err == nil { + o.workflowName.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "WorkflowDescription"); err == nil { + o.workflowDescription.SetFromDecode(child) + } + o.dueDate.Init(raw) + if val, err := raw.LookupErr("AllowedModuleRoles"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + qnames := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { qnames = append(qnames, s) } + } + o.allowedModuleRoles.SetFromDecode(qnames) + } + } + if child, err := codec.DecodeChild(raw, "WorkflowOnStateChangeEvent"); err == nil { + o.workflowOnStateChangeEvent.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "UsertaskOnStateChangeEvent"); err == nil { + o.usertaskOnStateChangeEvent.SetFromDecode(child) + } + if children, err := codec.DecodeChildren(raw, "OnWorkflowEvent"); err == nil { + for _, child := range children { + o.onWorkflowEvent.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "EventSubProcesses"); err == nil { + for _, child := range children { + o.eventSubProcesses.AppendFromDecode(child) + } + } + if child, err := codec.DecodeChild(raw, "Annotation"); err == nil { + o.annotation.SetFromDecode(child) + } + if child, err := codec.DecodeChild(raw, "WorkflowMetaData"); err == nil { + o.workflowMetaData.SetFromDecode(child) + } + o.workflowV2.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WorkflowCallParameterMapping +// ──────────────────────────────────────────────────────── + +type WorkflowCallParameterMapping struct { + element.Base + parameter *property.ByNameRef[element.Element] + expression *property.Primitive[string] +} + +// ParameterQualifiedName returns the value of the parameter property. +func (o *WorkflowCallParameterMapping) ParameterQualifiedName() string { + return o.parameter.QualifiedName() +} + +// SetParameterQualifiedName sets the value of the parameter property. +func (o *WorkflowCallParameterMapping) SetParameterQualifiedName(v string) { + o.parameter.SetQualifiedName(v) +} + +// Expression returns the value of the expression property. +func (o *WorkflowCallParameterMapping) Expression() string { + return o.expression.Get() +} + +// SetExpression sets the value of the expression property. +func (o *WorkflowCallParameterMapping) SetExpression(v string) { + o.expression.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowCallParameterMapping) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Parameter"); err == nil { + if s, ok := val.StringValueOK(); ok { o.parameter.SetFromDecode(s) } + } + o.expression.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WorkflowDefinitionSelection +// ──────────────────────────────────────────────────────── + +type WorkflowDefinitionSelection struct { + element.Base +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowDefinitionSelection) InitFromRaw(raw bson.Raw) { +} + +// ──────────────────────────────────────────────────────── +// WorkflowDefinitionNameSelection +// ──────────────────────────────────────────────────────── + +type WorkflowDefinitionNameSelection struct { + element.Base + workflow *property.ByNameRef[element.Element] +} + +// WorkflowQualifiedName returns the value of the workflow property. +func (o *WorkflowDefinitionNameSelection) WorkflowQualifiedName() string { + return o.workflow.QualifiedName() +} + +// SetWorkflowQualifiedName sets the value of the workflow property. +func (o *WorkflowDefinitionNameSelection) SetWorkflowQualifiedName(v string) { + o.workflow.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowDefinitionNameSelection) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Workflow"); err == nil { + if s, ok := val.StringValueOK(); ok { o.workflow.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// WorkflowDefinitionObjectSelection +// ──────────────────────────────────────────────────────── + +type WorkflowDefinitionObjectSelection struct { + element.Base + workflowDefinitionVariable *property.Primitive[string] +} + +// WorkflowDefinitionVariable returns the value of the workflowDefinitionVariable property. +func (o *WorkflowDefinitionObjectSelection) WorkflowDefinitionVariable() string { + return o.workflowDefinitionVariable.Get() +} + +// SetWorkflowDefinitionVariable sets the value of the workflowDefinitionVariable property. +func (o *WorkflowDefinitionObjectSelection) SetWorkflowDefinitionVariable(v string) { + o.workflowDefinitionVariable.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowDefinitionObjectSelection) InitFromRaw(raw bson.Raw) { + o.workflowDefinitionVariable.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WorkflowEventHandler +// ──────────────────────────────────────────────────────── + +type WorkflowEventHandler struct { + element.Base + description *property.Primitive[string] + microflowEventHandler *property.Part[element.Element] + eventTypes *property.EnumList[string] + documentation *property.Primitive[string] +} + +// Description returns the value of the description property. +func (o *WorkflowEventHandler) Description() string { + return o.description.Get() +} + +// SetDescription sets the value of the description property. +func (o *WorkflowEventHandler) SetDescription(v string) { + o.description.Set(v) +} + +// MicroflowEventHandler returns the value of the microflowEventHandler property. +func (o *WorkflowEventHandler) MicroflowEventHandler() element.Element { + return o.microflowEventHandler.Get() +} + +// SetMicroflowEventHandler sets the value of the microflowEventHandler property. +func (o *WorkflowEventHandler) SetMicroflowEventHandler(v element.Element) { + o.microflowEventHandler.Set(v) +} + +// EventTypesItems returns the value of the eventTypes property. +func (o *WorkflowEventHandler) EventTypesItems() []string { + return o.eventTypes.Items() +} + +// AddEventTypes appends a child element to the eventTypes list. +func (o *WorkflowEventHandler) AddEventTypes(v string) { + o.eventTypes.Append(v) +} + +// Documentation returns the value of the documentation property. +func (o *WorkflowEventHandler) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *WorkflowEventHandler) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowEventHandler) InitFromRaw(raw bson.Raw) { + o.description.Init(raw) + if child, err := codec.DecodeChild(raw, "MicroflowEventHandler"); err == nil { + o.microflowEventHandler.SetFromDecode(child) + } + if val, err := raw.LookupErr("EventTypes"); err == nil { + if arr, ok := val.ArrayOK(); ok { + vals, _ := arr.Values() + items := make([]string, 0, len(vals)) + for _, v := range vals { + if s, ok := v.StringValueOK(); ok { items = append(items, s) } + } + o.eventTypes.SetFromDecode(items) + } + } + o.documentation.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// WorkflowMetaData +// ──────────────────────────────────────────────────────── + +type WorkflowMetaData struct { + element.Base + detachedActivities *property.PartList[element.Element] + flowLines *property.PartList[element.Element] + annotation *property.PartList[element.Element] +} + +// DetachedActivitiesItems returns the value of the detachedActivities property. +func (o *WorkflowMetaData) DetachedActivitiesItems() []element.Element { + return o.detachedActivities.Items() +} + +// AddDetachedActivities appends a child element to the detachedActivities list. +func (o *WorkflowMetaData) AddDetachedActivities(v element.Element) { + o.detachedActivities.Append(v) +} + +// RemoveDetachedActivities removes the element at the given index from the detachedActivities list. +func (o *WorkflowMetaData) RemoveDetachedActivities(index int) { + o.detachedActivities.Remove(index) +} + +// FlowLinesItems returns the value of the flowLines property. +func (o *WorkflowMetaData) FlowLinesItems() []element.Element { + return o.flowLines.Items() +} + +// AddFlowLines appends a child element to the flowLines list. +func (o *WorkflowMetaData) AddFlowLines(v element.Element) { + o.flowLines.Append(v) +} + +// RemoveFlowLines removes the element at the given index from the flowLines list. +func (o *WorkflowMetaData) RemoveFlowLines(index int) { + o.flowLines.Remove(index) +} + +// AnnotationItems returns the value of the annotation property. +func (o *WorkflowMetaData) AnnotationItems() []element.Element { + return o.annotation.Items() +} + +// AddAnnotation appends a child element to the annotation list. +func (o *WorkflowMetaData) AddAnnotation(v element.Element) { + o.annotation.Append(v) +} + +// RemoveAnnotation removes the element at the given index from the annotation list. +func (o *WorkflowMetaData) RemoveAnnotation(index int) { + o.annotation.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowMetaData) InitFromRaw(raw bson.Raw) { + if children, err := codec.DecodeChildren(raw, "DetachedActivities"); err == nil { + for _, child := range children { + o.detachedActivities.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "FlowLines"); err == nil { + for _, child := range children { + o.flowLines.AppendFromDecode(child) + } + } + if children, err := codec.DecodeChildren(raw, "Annotation"); err == nil { + for _, child := range children { + o.annotation.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// WorkflowType +// ──────────────────────────────────────────────────────── + +type WorkflowType struct { + element.Base + entity *property.ByNameRef[element.Element] +} + +// EntityQualifiedName returns the value of the entity property. +func (o *WorkflowType) EntityQualifiedName() string { + return o.entity.QualifiedName() +} + +// SetEntityQualifiedName sets the value of the entity property. +func (o *WorkflowType) SetEntityQualifiedName(v string) { + o.entity.SetQualifiedName(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *WorkflowType) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("Entity"); err == nil { + if s, ok := val.StringValueOK(); ok { o.entity.SetFromDecode(s) } + } +} + +// ──────────────────────────────────────────────────────── +// XPathBasedTargeting +// ──────────────────────────────────────────────────────── + +type XPathBasedTargeting struct { + element.Base + xPathConstraint *property.Primitive[string] +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *XPathBasedTargeting) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *XPathBasedTargeting) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *XPathBasedTargeting) InitFromRaw(raw bson.Raw) { + o.xPathConstraint.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// XPathBasedUserSource +// ──────────────────────────────────────────────────────── + +type XPathBasedUserSource struct { + element.Base + xPathConstraint *property.Primitive[string] +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *XPathBasedUserSource) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *XPathBasedUserSource) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *XPathBasedUserSource) InitFromRaw(raw bson.Raw) { + o.xPathConstraint.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// XPathGroupTargeting +// ──────────────────────────────────────────────────────── + +type XPathGroupTargeting struct { + element.Base + xPathConstraint *property.Primitive[string] +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *XPathGroupTargeting) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *XPathGroupTargeting) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *XPathGroupTargeting) InitFromRaw(raw bson.Raw) { + o.xPathConstraint.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// XPathUserTargeting +// ──────────────────────────────────────────────────────── + +type XPathUserTargeting struct { + element.Base + xPathConstraint *property.Primitive[string] +} + +// XPathConstraint returns the value of the xPathConstraint property. +func (o *XPathUserTargeting) XPathConstraint() string { + return o.xPathConstraint.Get() +} + +// SetXPathConstraint sets the value of the xPathConstraint property. +func (o *XPathUserTargeting) SetXPathConstraint(v string) { + o.xPathConstraint.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *XPathUserTargeting) InitFromRaw(raw bson.Raw) { + o.xPathConstraint.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// ExclusiveSplitOutcome +// ──────────────────────────────────────────────────────── + +type ExclusiveSplitOutcome struct { + element.Base + name *property.Primitive[string] + caption *property.Primitive[string] + value *property.Primitive[string] + flow *property.Part[element.Element] +} + +// Name returns the value of the name property. +func (o *ExclusiveSplitOutcome) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *ExclusiveSplitOutcome) SetName(v string) { + o.name.Set(v) +} + +// Caption returns the value of the caption property. +func (o *ExclusiveSplitOutcome) Caption() string { + return o.caption.Get() +} + +// SetCaption sets the value of the caption property. +func (o *ExclusiveSplitOutcome) SetCaption(v string) { + o.caption.Set(v) +} + +// Value returns the value of the value property. +func (o *ExclusiveSplitOutcome) Value() string { + return o.value.Get() +} + +// SetValue sets the value of the value property. +func (o *ExclusiveSplitOutcome) SetValue(v string) { + o.value.Set(v) +} + +// Flow returns the value of the flow property. +func (o *ExclusiveSplitOutcome) Flow() element.Element { + return o.flow.Get() +} + +// SetFlow sets the value of the flow property. +func (o *ExclusiveSplitOutcome) SetFlow(v element.Element) { + o.flow.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *ExclusiveSplitOutcome) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.caption.Init(raw) + o.value.Init(raw) + if child, err := codec.DecodeChild(raw, "Flow"); err == nil { + o.flow.SetFromDecode(child) + } +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initAIAgentTaskActivity creates a AIAgentTaskActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAIAgentTaskActivity() *AIAgentTaskActivity { + o := &AIAgentTaskActivity{} + o.SetTypeName("Workflows$AIAgentTaskActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.outcomes = property.NewPartList[element.Element]("Outcomes") + o.outcomes.Bind(&o.Base, 6) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 7) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 8) + o.boundaryEvents = property.NewPartList[element.Element]("BoundaryEvents") + o.boundaryEvents.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.outcomes, o.microflow, o.parameterMappings, o.boundaryEvents, }) + return o +} + +// NewAIAgentTaskActivity creates a new AIAgentTaskActivity for user code. Marked dirty (bit 63 = new element). +func NewAIAgentTaskActivity() *AIAgentTaskActivity { + o := initAIAgentTaskActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAbsoluteAmountUserInput creates a AbsoluteAmountUserInput with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAbsoluteAmountUserInput() *AbsoluteAmountUserInput { + o := &AbsoluteAmountUserInput{} + o.SetTypeName("Workflows$AbsoluteAmountUserInput") + o.amount = property.NewPrimitive[int32]("Amount", property.DecodeInt32) + o.amount.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.amount, }) + return o +} + +// NewAbsoluteAmountUserInput creates a new AbsoluteAmountUserInput for user code. Marked dirty (bit 63 = new element). +func NewAbsoluteAmountUserInput() *AbsoluteAmountUserInput { + o := initAbsoluteAmountUserInput() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAllUserInput creates a AllUserInput with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAllUserInput() *AllUserInput { + o := &AllUserInput{} + o.SetTypeName("Workflows$AllUserInput") + o.SetProperties([]element.Property{}) + return o +} + +// NewAllUserInput creates a new AllUserInput for user code. Marked dirty (bit 63 = new element). +func NewAllUserInput() *AllUserInput { + o := initAllUserInput() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initAnnotation creates a Annotation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initAnnotation() *Annotation { + o := &Annotation{} + o.SetTypeName("Workflows$AnnotationActivity") + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.description, }) + return o +} + +// NewAnnotation creates a new Annotation for user code. Marked dirty (bit 63 = new element). +func NewAnnotation() *Annotation { + o := initAnnotation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBezierCurve creates a BezierCurve with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBezierCurve() *BezierCurve { + o := &BezierCurve{} + o.SetTypeName("Workflows$BezierCurve") + o.originControlVector = property.NewPrimitive[string]("OriginControlVector", property.DecodeString) + o.originControlVector.Bind(&o.Base, 0) + o.destinationControlVector = property.NewPrimitive[string]("DestinationControlVector", property.DecodeString) + o.destinationControlVector.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.originControlVector, o.destinationControlVector, }) + return o +} + +// NewBezierCurve creates a new BezierCurve for user code. Marked dirty (bit 63 = new element). +func NewBezierCurve() *BezierCurve { + o := initBezierCurve() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBooleanCase creates a BooleanCase with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBooleanCase() *BooleanCase { + o := &BooleanCase{} + o.SetTypeName("Workflows$BooleanCase") + o.value = property.NewPrimitive[bool]("Value", property.DecodeBool) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value, }) + return o +} + +// NewBooleanCase creates a new BooleanCase for user code. Marked dirty (bit 63 = new element). +func NewBooleanCase() *BooleanCase { + o := initBooleanCase() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBooleanConditionOutcome creates a BooleanConditionOutcome with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBooleanConditionOutcome() *BooleanConditionOutcome { + o := &BooleanConditionOutcome{} + o.SetTypeName("Workflows$BooleanConditionOutcome") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 1) + o.value = property.NewPrimitive[bool]("Value", property.DecodeBool) + o.value.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.persistentId, o.flow, o.value, }) + return o +} + +// NewBooleanConditionOutcome creates a new BooleanConditionOutcome for user code. Marked dirty (bit 63 = new element). +func NewBooleanConditionOutcome() *BooleanConditionOutcome { + o := initBooleanConditionOutcome() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initBoundaryEvent creates a BoundaryEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initBoundaryEvent() *BoundaryEvent { + o := &BoundaryEvent{} + o.SetTypeName("Workflows$BoundaryEvent") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.isInterrupting = property.NewPrimitive[bool]("IsInterrupting", property.DecodeBool) + o.isInterrupting.Bind(&o.Base, 4) + o.eventType = property.NewPrimitive[string]("EventType", property.DecodeString) + o.eventType.Bind(&o.Base, 5) + o.delay = property.NewPrimitive[string]("Delay", property.DecodeString) + o.delay.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.persistentId, o.flow, o.caption, o.annotation, o.isInterrupting, o.eventType, o.delay, }) + return o +} + +// NewBoundaryEvent creates a new BoundaryEvent for user code. Marked dirty (bit 63 = new element). +func NewBoundaryEvent() *BoundaryEvent { + o := initBoundaryEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCallMicroflowActivity creates a CallMicroflowActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCallMicroflowActivity() *CallMicroflowActivity { + o := &CallMicroflowActivity{} + o.SetTypeName("Workflows$CallMicroflowActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.outcomes = property.NewPartList[element.Element]("Outcomes") + o.outcomes.Bind(&o.Base, 6) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 7) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 8) + o.boundaryEvents = property.NewPartList[element.Element]("BoundaryEvents") + o.boundaryEvents.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.outcomes, o.microflow, o.parameterMappings, o.boundaryEvents, }) + return o +} + +// NewCallMicroflowActivity creates a new CallMicroflowActivity for user code. Marked dirty (bit 63 = new element). +func NewCallMicroflowActivity() *CallMicroflowActivity { + o := initCallMicroflowActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCallMicroflowTask creates a CallMicroflowTask with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCallMicroflowTask() *CallMicroflowTask { + o := &CallMicroflowTask{} + o.SetTypeName("Workflows$CallMicroflowTask") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.outcomes = property.NewPartList[element.Element]("Outcomes") + o.outcomes.Bind(&o.Base, 6) + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 7) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 8) + o.boundaryEvents = property.NewPartList[element.Element]("BoundaryEvents") + o.boundaryEvents.Bind(&o.Base, 9) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.outcomes, o.microflow, o.parameterMappings, o.boundaryEvents, }) + return o +} + +// NewCallMicroflowTask creates a new CallMicroflowTask for user code. Marked dirty (bit 63 = new element). +func NewCallMicroflowTask() *CallMicroflowTask { + o := initCallMicroflowTask() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initCallWorkflowActivity creates a CallWorkflowActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initCallWorkflowActivity() *CallWorkflowActivity { + o := &CallWorkflowActivity{} + o.SetTypeName("Workflows$CallWorkflowActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.workflow = property.NewByNameRef[element.Element]("Workflow", "Workflows$Workflow") + o.workflow.Bind(&o.Base, 6) + o.parameterExpression = property.NewPrimitive[string]("ParameterExpression", property.DecodeString) + o.parameterExpression.Bind(&o.Base, 7) + o.parameterMappings = property.NewPartList[element.Element]("ParameterMappings") + o.parameterMappings.Bind(&o.Base, 8) + o.boundaryEvents = property.NewPartList[element.Element]("BoundaryEvents") + o.boundaryEvents.Bind(&o.Base, 9) + o.executeAsync = property.NewPrimitive[bool]("ExecuteAsync", property.DecodeBool) + o.executeAsync.Bind(&o.Base, 10) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.workflow, o.parameterExpression, o.parameterMappings, o.boundaryEvents, o.executeAsync, }) + return o +} + +// NewCallWorkflowActivity creates a new CallWorkflowActivity for user code. Marked dirty (bit 63 = new element). +func NewCallWorkflowActivity() *CallWorkflowActivity { + o := initCallWorkflowActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initConsensusCompletionCriteria creates a ConsensusCompletionCriteria with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initConsensusCompletionCriteria() *ConsensusCompletionCriteria { + o := &ConsensusCompletionCriteria{} + o.SetTypeName("Workflows$ConsensusCompletionCriteria") + o.fallbackOutcome = property.NewByIdRef[element.Element]("FallbackOutcomePointer") + o.fallbackOutcome.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.fallbackOutcome, }) + return o +} + +// NewConsensusCompletionCriteria creates a new ConsensusCompletionCriteria for user code. Marked dirty (bit 63 = new element). +func NewConsensusCompletionCriteria() *ConsensusCompletionCriteria { + o := initConsensusCompletionCriteria() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEmptyUserSource creates a EmptyUserSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEmptyUserSource() *EmptyUserSource { + o := &EmptyUserSource{} + o.SetTypeName("Workflows$EmptyUserSource") + o.SetProperties([]element.Property{}) + return o +} + +// NewEmptyUserSource creates a new EmptyUserSource for user code. Marked dirty (bit 63 = new element). +func NewEmptyUserSource() *EmptyUserSource { + o := initEmptyUserSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEndOfBoundaryEventPathActivity creates a EndOfBoundaryEventPathActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEndOfBoundaryEventPathActivity() *EndOfBoundaryEventPathActivity { + o := &EndOfBoundaryEventPathActivity{} + o.SetTypeName("Workflows$EndOfBoundaryEventPathActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, }) + return o +} + +// NewEndOfBoundaryEventPathActivity creates a new EndOfBoundaryEventPathActivity for user code. Marked dirty (bit 63 = new element). +func NewEndOfBoundaryEventPathActivity() *EndOfBoundaryEventPathActivity { + o := initEndOfBoundaryEventPathActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEndOfParallelSplitPathActivity creates a EndOfParallelSplitPathActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEndOfParallelSplitPathActivity() *EndOfParallelSplitPathActivity { + o := &EndOfParallelSplitPathActivity{} + o.SetTypeName("Workflows$EndOfParallelSplitPathActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, }) + return o +} + +// NewEndOfParallelSplitPathActivity creates a new EndOfParallelSplitPathActivity for user code. Marked dirty (bit 63 = new element). +func NewEndOfParallelSplitPathActivity() *EndOfParallelSplitPathActivity { + o := initEndOfParallelSplitPathActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEndWorkflowActivity creates a EndWorkflowActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEndWorkflowActivity() *EndWorkflowActivity { + o := &EndWorkflowActivity{} + o.SetTypeName("Workflows$EndWorkflowActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, }) + return o +} + +// NewEndWorkflowActivity creates a new EndWorkflowActivity for user code. Marked dirty (bit 63 = new element). +func NewEndWorkflowActivity() *EndWorkflowActivity { + o := initEndWorkflowActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEnumerationValueConditionOutcome creates a EnumerationValueConditionOutcome with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEnumerationValueConditionOutcome() *EnumerationValueConditionOutcome { + o := &EnumerationValueConditionOutcome{} + o.SetTypeName("Workflows$EnumerationValueConditionOutcome") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 1) + o.value = property.NewByNameRef[element.Element]("Value", "Enumerations$EnumerationValue") + o.value.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.persistentId, o.flow, o.value, }) + return o +} + +// NewEnumerationValueConditionOutcome creates a new EnumerationValueConditionOutcome for user code. Marked dirty (bit 63 = new element). +func NewEnumerationValueConditionOutcome() *EnumerationValueConditionOutcome { + o := initEnumerationValueConditionOutcome() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initEventSubProcess creates a EventSubProcess with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initEventSubProcess() *EventSubProcess { + o := &EventSubProcess{} + o.SetTypeName("Workflows$EventSubProcess") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 2) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 3) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.persistentId, o.name, o.flow, o.caption, o.annotation, }) + return o +} + +// NewEventSubProcess creates a new EventSubProcess for user code. Marked dirty (bit 63 = new element). +func NewEventSubProcess() *EventSubProcess { + o := initEventSubProcess() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExclusiveSplitActivity creates a ExclusiveSplitActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExclusiveSplitActivity() *ExclusiveSplitActivity { + o := &ExclusiveSplitActivity{} + o.SetTypeName("Workflows$ExclusiveSplitActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.outcomes = property.NewPartList[element.Element]("Outcomes") + o.outcomes.Bind(&o.Base, 6) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.outcomes, o.expression, }) + return o +} + +// NewExclusiveSplitActivity creates a new ExclusiveSplitActivity for user code. Marked dirty (bit 63 = new element). +func NewExclusiveSplitActivity() *ExclusiveSplitActivity { + o := initExclusiveSplitActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFloatingAnnotation creates a FloatingAnnotation with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFloatingAnnotation() *FloatingAnnotation { + o := &FloatingAnnotation{} + o.SetTypeName("Workflows$FloatingAnnotation") + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 0) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 1) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.description, o.relativeMiddlePoint, o.size, }) + return o +} + +// NewFloatingAnnotation creates a new FloatingAnnotation for user code. Marked dirty (bit 63 = new element). +func NewFloatingAnnotation() *FloatingAnnotation { + o := initFloatingAnnotation() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFlow creates a Flow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFlow() *Flow { + o := &Flow{} + o.SetTypeName("Workflows$Flow") + o.activities = property.NewPartList[element.Element]("Activities") + o.activities.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.activities, }) + return o +} + +// NewFlow creates a new Flow for user code. Marked dirty (bit 63 = new element). +func NewFlow() *Flow { + o := initFlow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initFlowLine creates a FlowLine with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initFlowLine() *FlowLine { + o := &FlowLine{} + o.SetTypeName("Workflows$FlowLine") + o.origin = property.NewByIdRef[element.Element]("OriginPointer") + o.origin.Bind(&o.Base, 0) + o.destination = property.NewByIdRef[element.Element]("DestinationPointer") + o.destination.Bind(&o.Base, 1) + o.line = property.NewPart[element.Element]("Line") + o.line.Bind(&o.Base, 2) + o.originConnectionSide = property.NewEnum[string]("OriginConnectionSide") + o.originConnectionSide.Bind(&o.Base, 3) + o.originalConnectionFactor = property.NewPrimitive[float64]("OriginalConnectionFactor", property.DecodeFloat64) + o.originalConnectionFactor.Bind(&o.Base, 4) + o.destinationConnectionSide = property.NewEnum[string]("DestinationConnectionSide") + o.destinationConnectionSide.Bind(&o.Base, 5) + o.destinationConnectionFactor = property.NewPrimitive[float64]("DestinationConnectionFactor", property.DecodeFloat64) + o.destinationConnectionFactor.Bind(&o.Base, 6) + o.caseValues = property.NewPartList[element.Element]("CaseValues") + o.caseValues.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.origin, o.destination, o.line, o.originConnectionSide, o.originalConnectionFactor, o.destinationConnectionSide, o.destinationConnectionFactor, o.caseValues, }) + return o +} + +// NewFlowLine creates a new FlowLine for user code. Marked dirty (bit 63 = new element). +func NewFlowLine() *FlowLine { + o := initFlowLine() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initInterruptingTimerBoundaryEvent creates a InterruptingTimerBoundaryEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initInterruptingTimerBoundaryEvent() *InterruptingTimerBoundaryEvent { + o := &InterruptingTimerBoundaryEvent{} + o.SetTypeName("Workflows$InterruptingTimerBoundaryEvent") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.isInterrupting = property.NewPrimitive[bool]("IsInterrupting", property.DecodeBool) + o.isInterrupting.Bind(&o.Base, 4) + o.eventType = property.NewPrimitive[string]("EventType", property.DecodeString) + o.eventType.Bind(&o.Base, 5) + o.delay = property.NewPrimitive[string]("Delay", property.DecodeString) + o.delay.Bind(&o.Base, 6) + o.firstExecutionTime = property.NewPrimitive[string]("FirstExecutionTime", property.DecodeString) + o.firstExecutionTime.Bind(&o.Base, 7) + o.SetProperties([]element.Property{o.persistentId, o.flow, o.caption, o.annotation, o.isInterrupting, o.eventType, o.delay, o.firstExecutionTime, }) + return o +} + +// NewInterruptingTimerBoundaryEvent creates a new InterruptingTimerBoundaryEvent for user code. Marked dirty (bit 63 = new element). +func NewInterruptingTimerBoundaryEvent() *InterruptingTimerBoundaryEvent { + o := initInterruptingTimerBoundaryEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initJumpToActivity creates a JumpToActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initJumpToActivity() *JumpToActivity { + o := &JumpToActivity{} + o.SetTypeName("Workflows$JumpToActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.targetActivity = property.NewByNameRef[element.Element]("TargetActivity", "Workflows$WorkflowActivity") + o.targetActivity.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.targetActivity, }) + return o +} + +// NewJumpToActivity creates a new JumpToActivity for user code. Marked dirty (bit 63 = new element). +func NewJumpToActivity() *JumpToActivity { + o := initJumpToActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initLinearRecurrence creates a LinearRecurrence with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initLinearRecurrence() *LinearRecurrence { + o := &LinearRecurrence{} + o.SetTypeName("Workflows$LinearRecurrence") + o.intervalType = property.NewEnum[string]("IntervalType") + o.intervalType.Bind(&o.Base, 0) + o.interval = property.NewPrimitive[int32]("Interval", property.DecodeInt32) + o.interval.Bind(&o.Base, 1) + o.maxExecutions = property.NewPrimitive[int32]("MaxExecutions", property.DecodeInt32) + o.maxExecutions.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.intervalType, o.interval, o.maxExecutions, }) + return o +} + +// NewLinearRecurrence creates a new LinearRecurrence for user code. Marked dirty (bit 63 = new element). +func NewLinearRecurrence() *LinearRecurrence { + o := initLinearRecurrence() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMajorityCompletionCriteria creates a MajorityCompletionCriteria with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMajorityCompletionCriteria() *MajorityCompletionCriteria { + o := &MajorityCompletionCriteria{} + o.SetTypeName("Workflows$MajorityCompletionCriteria") + o.completionType = property.NewEnum[string]("CompletionType") + o.completionType.Bind(&o.Base, 0) + o.fallbackOutcome = property.NewByIdRef[element.Element]("FallbackOutcomePointer") + o.fallbackOutcome.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.completionType, o.fallbackOutcome, }) + return o +} + +// NewMajorityCompletionCriteria creates a new MajorityCompletionCriteria for user code. Marked dirty (bit 63 = new element). +func NewMajorityCompletionCriteria() *MajorityCompletionCriteria { + o := initMajorityCompletionCriteria() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMergeActivity creates a MergeActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMergeActivity() *MergeActivity { + o := &MergeActivity{} + o.SetTypeName("Workflows$MergeActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, }) + return o +} + +// NewMergeActivity creates a new MergeActivity for user code. Marked dirty (bit 63 = new element). +func NewMergeActivity() *MergeActivity { + o := initMergeActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowBasedEvent creates a MicroflowBasedEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowBasedEvent() *MicroflowBasedEvent { + o := &MicroflowBasedEvent{} + o.SetTypeName("Workflows$MicroflowBasedEvent") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow, }) + return o +} + +// NewMicroflowBasedEvent creates a new MicroflowBasedEvent for user code. Marked dirty (bit 63 = new element). +func NewMicroflowBasedEvent() *MicroflowBasedEvent { + o := initMicroflowBasedEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowBasedUserSource creates a MicroflowBasedUserSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowBasedUserSource() *MicroflowBasedUserSource { + o := &MicroflowBasedUserSource{} + o.SetTypeName("Workflows$MicroflowBasedUserSource") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow, }) + return o +} + +// NewMicroflowBasedUserSource creates a new MicroflowBasedUserSource for user code. Marked dirty (bit 63 = new element). +func NewMicroflowBasedUserSource() *MicroflowBasedUserSource { + o := initMicroflowBasedUserSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowCallParameterMapping creates a MicroflowCallParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowCallParameterMapping() *MicroflowCallParameterMapping { + o := &MicroflowCallParameterMapping{} + o.SetTypeName("Workflows$MicroflowCallParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Microflows$MicroflowParameter") + o.parameter.Bind(&o.Base, 0) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameter, o.expression, }) + return o +} + +// NewMicroflowCallParameterMapping creates a new MicroflowCallParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewMicroflowCallParameterMapping() *MicroflowCallParameterMapping { + o := initMicroflowCallParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowCompletionCriteria creates a MicroflowCompletionCriteria with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowCompletionCriteria() *MicroflowCompletionCriteria { + o := &MicroflowCompletionCriteria{} + o.SetTypeName("Workflows$MicroflowCompletionCriteria") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow, }) + return o +} + +// NewMicroflowCompletionCriteria creates a new MicroflowCompletionCriteria for user code. Marked dirty (bit 63 = new element). +func NewMicroflowCompletionCriteria() *MicroflowCompletionCriteria { + o := initMicroflowCompletionCriteria() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowEventHandler creates a MicroflowEventHandler with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowEventHandler() *MicroflowEventHandler { + o := &MicroflowEventHandler{} + o.SetTypeName("Workflows$MicroflowEventHandler") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow, }) + return o +} + +// NewMicroflowEventHandler creates a new MicroflowEventHandler for user code. Marked dirty (bit 63 = new element). +func NewMicroflowEventHandler() *MicroflowEventHandler { + o := initMicroflowEventHandler() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowGroupTargeting creates a MicroflowGroupTargeting with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowGroupTargeting() *MicroflowGroupTargeting { + o := &MicroflowGroupTargeting{} + o.SetTypeName("Workflows$MicroflowGroupTargeting") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow, }) + return o +} + +// NewMicroflowGroupTargeting creates a new MicroflowGroupTargeting for user code. Marked dirty (bit 63 = new element). +func NewMicroflowGroupTargeting() *MicroflowGroupTargeting { + o := initMicroflowGroupTargeting() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMicroflowUserTargeting creates a MicroflowUserTargeting with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMicroflowUserTargeting() *MicroflowUserTargeting { + o := &MicroflowUserTargeting{} + o.SetTypeName("Workflows$MicroflowUserTargeting") + o.microflow = property.NewByNameRef[element.Element]("Microflow", "Microflows$Microflow") + o.microflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.microflow, }) + return o +} + +// NewMicroflowUserTargeting creates a new MicroflowUserTargeting for user code. Marked dirty (bit 63 = new element). +func NewMicroflowUserTargeting() *MicroflowUserTargeting { + o := initMicroflowUserTargeting() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMultiInputCompletion creates a MultiInputCompletion with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMultiInputCompletion() *MultiInputCompletion { + o := &MultiInputCompletion{} + o.SetTypeName("Workflows$MultiInputCompletion") + o.targetUserInput = property.NewPart[element.Element]("TargetUserInput") + o.targetUserInput.Bind(&o.Base, 0) + o.completionCriteria = property.NewPart[element.Element]("CompletionCriteria") + o.completionCriteria.Bind(&o.Base, 1) + o.awaitAllUsers = property.NewPrimitive[bool]("AwaitAllUsers", property.DecodeBool) + o.awaitAllUsers.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.targetUserInput, o.completionCriteria, o.awaitAllUsers, }) + return o +} + +// NewMultiInputCompletion creates a new MultiInputCompletion for user code. Marked dirty (bit 63 = new element). +func NewMultiInputCompletion() *MultiInputCompletion { + o := initMultiInputCompletion() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initMultiUserTaskActivity creates a MultiUserTaskActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initMultiUserTaskActivity() *MultiUserTaskActivity { + o := &MultiUserTaskActivity{} + o.SetTypeName("Workflows$MultiUserTaskActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.taskPage = property.NewPart[element.Element]("TaskPage") + o.taskPage.Bind(&o.Base, 6) + o.taskName = property.NewPart[element.Element]("TaskName") + o.taskName.Bind(&o.Base, 7) + o.taskDescription = property.NewPart[element.Element]("TaskDescription") + o.taskDescription.Bind(&o.Base, 8) + o.dueDate = property.NewPrimitive[string]("DueDate", property.DecodeString) + o.dueDate.Bind(&o.Base, 9) + o.userSource = property.NewPart[element.Element]("UserSource") + o.userSource.Bind(&o.Base, 10) + o.userTargeting = property.NewPart[element.Element]("UserTargeting") + o.userTargeting.Bind(&o.Base, 11) + o.outcomes = property.NewPartList[element.Element]("Outcomes") + o.outcomes.Bind(&o.Base, 12) + o.boundaryEvents = property.NewPartList[element.Element]("BoundaryEvents") + o.boundaryEvents.Bind(&o.Base, 13) + o.onCreatedEvent = property.NewPart[element.Element]("OnCreatedEvent") + o.onCreatedEvent.Bind(&o.Base, 14) + o.autoAssignSingleTargetUser = property.NewPrimitive[bool]("AutoAssignSingleTargetUser", property.DecodeBool) + o.autoAssignSingleTargetUser.Bind(&o.Base, 15) + o.targetUserInput = property.NewPart[element.Element]("TargetUserInput") + o.targetUserInput.Bind(&o.Base, 16) + o.completionCriteria = property.NewPart[element.Element]("CompletionCriteria") + o.completionCriteria.Bind(&o.Base, 17) + o.awaitAllUsers = property.NewPrimitive[bool]("AwaitAllUsers", property.DecodeBool) + o.awaitAllUsers.Bind(&o.Base, 18) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.taskPage, o.taskName, o.taskDescription, o.dueDate, o.userSource, o.userTargeting, o.outcomes, o.boundaryEvents, o.onCreatedEvent, o.autoAssignSingleTargetUser, o.targetUserInput, o.completionCriteria, o.awaitAllUsers, }) + return o +} + +// NewMultiUserTaskActivity creates a new MultiUserTaskActivity for user code. Marked dirty (bit 63 = new element). +func NewMultiUserTaskActivity() *MultiUserTaskActivity { + o := initMultiUserTaskActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNoEvent creates a NoEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNoEvent() *NoEvent { + o := &NoEvent{} + o.SetTypeName("Workflows$NoEvent") + o.SetProperties([]element.Property{}) + return o +} + +// NewNoEvent creates a new NoEvent for user code. Marked dirty (bit 63 = new element). +func NewNoEvent() *NoEvent { + o := initNoEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNoUserTargeting creates a NoUserTargeting with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNoUserTargeting() *NoUserTargeting { + o := &NoUserTargeting{} + o.SetTypeName("Workflows$NoUserTargeting") + o.SetProperties([]element.Property{}) + return o +} + +// NewNoUserTargeting creates a new NoUserTargeting for user code. Marked dirty (bit 63 = new element). +func NewNoUserTargeting() *NoUserTargeting { + o := initNoUserTargeting() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNonInterruptingNotificationEventSubProcessStartActivity creates a NonInterruptingNotificationEventSubProcessStartActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNonInterruptingNotificationEventSubProcessStartActivity() *NonInterruptingNotificationEventSubProcessStartActivity { + o := &NonInterruptingNotificationEventSubProcessStartActivity{} + o.SetTypeName("Workflows$NonInterruptingNotificationEventSubProcessStartActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, }) + return o +} + +// NewNonInterruptingNotificationEventSubProcessStartActivity creates a new NonInterruptingNotificationEventSubProcessStartActivity for user code. Marked dirty (bit 63 = new element). +func NewNonInterruptingNotificationEventSubProcessStartActivity() *NonInterruptingNotificationEventSubProcessStartActivity { + o := initNonInterruptingNotificationEventSubProcessStartActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNonInterruptingNotificationEventSubProcessStartActivityTarget creates a NonInterruptingNotificationEventSubProcessStartActivityTarget with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNonInterruptingNotificationEventSubProcessStartActivityTarget() *NonInterruptingNotificationEventSubProcessStartActivityTarget { + o := &NonInterruptingNotificationEventSubProcessStartActivityTarget{} + o.SetTypeName("Workflows$NonInterruptingNotificationEventSubProcessStartActivityTarget") + o.activity = property.NewByNameRef[element.Element]("Activity", "Workflows$NonInterruptingNotificationEventSubProcessStartActivity") + o.activity.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.activity, }) + return o +} + +// NewNonInterruptingNotificationEventSubProcessStartActivityTarget creates a new NonInterruptingNotificationEventSubProcessStartActivityTarget for user code. Marked dirty (bit 63 = new element). +func NewNonInterruptingNotificationEventSubProcessStartActivityTarget() *NonInterruptingNotificationEventSubProcessStartActivityTarget { + o := initNonInterruptingNotificationEventSubProcessStartActivityTarget() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNonInterruptingTimerBoundaryEvent creates a NonInterruptingTimerBoundaryEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNonInterruptingTimerBoundaryEvent() *NonInterruptingTimerBoundaryEvent { + o := &NonInterruptingTimerBoundaryEvent{} + o.SetTypeName("Workflows$NonInterruptingTimerBoundaryEvent") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.isInterrupting = property.NewPrimitive[bool]("IsInterrupting", property.DecodeBool) + o.isInterrupting.Bind(&o.Base, 4) + o.eventType = property.NewPrimitive[string]("EventType", property.DecodeString) + o.eventType.Bind(&o.Base, 5) + o.delay = property.NewPrimitive[string]("Delay", property.DecodeString) + o.delay.Bind(&o.Base, 6) + o.firstExecutionTime = property.NewPrimitive[string]("FirstExecutionTime", property.DecodeString) + o.firstExecutionTime.Bind(&o.Base, 7) + o.recurrence = property.NewPart[element.Element]("Recurrence") + o.recurrence.Bind(&o.Base, 8) + o.SetProperties([]element.Property{o.persistentId, o.flow, o.caption, o.annotation, o.isInterrupting, o.eventType, o.delay, o.firstExecutionTime, o.recurrence, }) + return o +} + +// NewNonInterruptingTimerBoundaryEvent creates a new NonInterruptingTimerBoundaryEvent for user code. Marked dirty (bit 63 = new element). +func NewNonInterruptingTimerBoundaryEvent() *NonInterruptingTimerBoundaryEvent { + o := initNonInterruptingTimerBoundaryEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initNotifyWaitForNotificationActivityTarget creates a NotifyWaitForNotificationActivityTarget with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initNotifyWaitForNotificationActivityTarget() *NotifyWaitForNotificationActivityTarget { + o := &NotifyWaitForNotificationActivityTarget{} + o.SetTypeName("Workflows$NotifyWaitForNotificationActivityTarget") + o.activity = property.NewByNameRef[element.Element]("Activity", "Workflows$WaitForNotificationActivity") + o.activity.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.activity, }) + return o +} + +// NewNotifyWaitForNotificationActivityTarget creates a new NotifyWaitForNotificationActivityTarget for user code. Marked dirty (bit 63 = new element). +func NewNotifyWaitForNotificationActivityTarget() *NotifyWaitForNotificationActivityTarget { + o := initNotifyWaitForNotificationActivityTarget() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initOrthogonalPath creates a OrthogonalPath with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initOrthogonalPath() *OrthogonalPath { + o := &OrthogonalPath{} + o.SetTypeName("Workflows$OrthogonalPath") + o.segmentPositions = property.NewPrimitive[string]("SegmentPositions", property.DecodeString) + o.segmentPositions.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.segmentPositions, }) + return o +} + +// NewOrthogonalPath creates a new OrthogonalPath for user code. Marked dirty (bit 63 = new element). +func NewOrthogonalPath() *OrthogonalPath { + o := initOrthogonalPath() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPageParameterMapping creates a PageParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPageParameterMapping() *PageParameterMapping { + o := &PageParameterMapping{} + o.SetTypeName("Workflows$PageParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Forms$PageParameter") + o.parameter.Bind(&o.Base, 0) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameter, o.expression, }) + return o +} + +// NewPageParameterMapping creates a new PageParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewPageParameterMapping() *PageParameterMapping { + o := initPageParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPageReference creates a PageReference with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPageReference() *PageReference { + o := &PageReference{} + o.SetTypeName("Workflows$PageReference") + o.page = property.NewByNameRef[element.Element]("Page", "Forms$Page") + o.page.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.page, }) + return o +} + +// NewPageReference creates a new PageReference for user code. Marked dirty (bit 63 = new element). +func NewPageReference() *PageReference { + o := initPageReference() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initParallelSplitActivity creates a ParallelSplitActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initParallelSplitActivity() *ParallelSplitActivity { + o := &ParallelSplitActivity{} + o.SetTypeName("Workflows$ParallelSplitActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.outcomes = property.NewPartList[element.Element]("Outcomes") + o.outcomes.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.outcomes, }) + return o +} + +// NewParallelSplitActivity creates a new ParallelSplitActivity for user code. Marked dirty (bit 63 = new element). +func NewParallelSplitActivity() *ParallelSplitActivity { + o := initParallelSplitActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initParallelSplitOutcome creates a ParallelSplitOutcome with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initParallelSplitOutcome() *ParallelSplitOutcome { + o := &ParallelSplitOutcome{} + o.SetTypeName("Workflows$ParallelSplitOutcome") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.persistentId, o.flow, }) + return o +} + +// NewParallelSplitOutcome creates a new ParallelSplitOutcome for user code. Marked dirty (bit 63 = new element). +func NewParallelSplitOutcome() *ParallelSplitOutcome { + o := initParallelSplitOutcome() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initParameter creates a Parameter with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initParameter() *Parameter { + o := &Parameter{} + o.SetTypeName("Workflows$Parameter") + o.entityRef = property.NewPart[element.Element]("EntityRef") + o.entityRef.Bind(&o.Base, 0) + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 1) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.entityRef, o.entity, o.name, }) + return o +} + +// NewParameter creates a new Parameter for user code. Marked dirty (bit 63 = new element). +func NewParameter() *Parameter { + o := initParameter() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initPercentageAmountUserInput creates a PercentageAmountUserInput with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initPercentageAmountUserInput() *PercentageAmountUserInput { + o := &PercentageAmountUserInput{} + o.SetTypeName("Workflows$PercentageAmountUserInput") + o.percentage = property.NewPrimitive[int32]("Percentage", property.DecodeInt32) + o.percentage.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.percentage, }) + return o +} + +// NewPercentageAmountUserInput creates a new PercentageAmountUserInput for user code. Marked dirty (bit 63 = new element). +func NewPercentageAmountUserInput() *PercentageAmountUserInput { + o := initPercentageAmountUserInput() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSingleInputCompletion creates a SingleInputCompletion with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSingleInputCompletion() *SingleInputCompletion { + o := &SingleInputCompletion{} + o.SetTypeName("Workflows$SingleInputCompletion") + o.SetProperties([]element.Property{}) + return o +} + +// NewSingleInputCompletion creates a new SingleInputCompletion for user code. Marked dirty (bit 63 = new element). +func NewSingleInputCompletion() *SingleInputCompletion { + o := initSingleInputCompletion() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initSingleUserTaskActivity creates a SingleUserTaskActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initSingleUserTaskActivity() *SingleUserTaskActivity { + o := &SingleUserTaskActivity{} + o.SetTypeName("Workflows$SingleUserTaskActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.taskPage = property.NewPart[element.Element]("TaskPage") + o.taskPage.Bind(&o.Base, 6) + o.taskName = property.NewPart[element.Element]("TaskName") + o.taskName.Bind(&o.Base, 7) + o.taskDescription = property.NewPart[element.Element]("TaskDescription") + o.taskDescription.Bind(&o.Base, 8) + o.dueDate = property.NewPrimitive[string]("DueDate", property.DecodeString) + o.dueDate.Bind(&o.Base, 9) + o.userSource = property.NewPart[element.Element]("UserSource") + o.userSource.Bind(&o.Base, 10) + o.userTargeting = property.NewPart[element.Element]("UserTargeting") + o.userTargeting.Bind(&o.Base, 11) + o.outcomes = property.NewPartList[element.Element]("Outcomes") + o.outcomes.Bind(&o.Base, 12) + o.boundaryEvents = property.NewPartList[element.Element]("BoundaryEvents") + o.boundaryEvents.Bind(&o.Base, 13) + o.onCreatedEvent = property.NewPart[element.Element]("OnCreatedEvent") + o.onCreatedEvent.Bind(&o.Base, 14) + o.autoAssignSingleTargetUser = property.NewPrimitive[bool]("AutoAssignSingleTargetUser", property.DecodeBool) + o.autoAssignSingleTargetUser.Bind(&o.Base, 15) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.taskPage, o.taskName, o.taskDescription, o.dueDate, o.userSource, o.userTargeting, o.outcomes, o.boundaryEvents, o.onCreatedEvent, o.autoAssignSingleTargetUser, }) + return o +} + +// NewSingleUserTaskActivity creates a new SingleUserTaskActivity for user code. Marked dirty (bit 63 = new element). +func NewSingleUserTaskActivity() *SingleUserTaskActivity { + o := initSingleUserTaskActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStartWorkflowActivity creates a StartWorkflowActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStartWorkflowActivity() *StartWorkflowActivity { + o := &StartWorkflowActivity{} + o.SetTypeName("Workflows$StartWorkflowActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, }) + return o +} + +// NewStartWorkflowActivity creates a new StartWorkflowActivity for user code. Marked dirty (bit 63 = new element). +func NewStartWorkflowActivity() *StartWorkflowActivity { + o := initStartWorkflowActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initStringCase creates a StringCase with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initStringCase() *StringCase { + o := &StringCase{} + o.SetTypeName("Workflows$StringCase") + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.value, }) + return o +} + +// NewStringCase creates a new StringCase for user code. Marked dirty (bit 63 = new element). +func NewStringCase() *StringCase { + o := initStringCase() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initThresholdCompletionCriteria creates a ThresholdCompletionCriteria with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initThresholdCompletionCriteria() *ThresholdCompletionCriteria { + o := &ThresholdCompletionCriteria{} + o.SetTypeName("Workflows$ThresholdCompletionCriteria") + o.completionType = property.NewEnum[string]("CompletionType") + o.completionType.Bind(&o.Base, 0) + o.threshold = property.NewPrimitive[int32]("Threshold", property.DecodeInt32) + o.threshold.Bind(&o.Base, 1) + o.fallbackOutcome = property.NewByIdRef[element.Element]("FallbackOutcomePointer") + o.fallbackOutcome.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.completionType, o.threshold, o.fallbackOutcome, }) + return o +} + +// NewThresholdCompletionCriteria creates a new ThresholdCompletionCriteria for user code. Marked dirty (bit 63 = new element). +func NewThresholdCompletionCriteria() *ThresholdCompletionCriteria { + o := initThresholdCompletionCriteria() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initTimerBoundaryEvent creates a TimerBoundaryEvent with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initTimerBoundaryEvent() *TimerBoundaryEvent { + o := &TimerBoundaryEvent{} + o.SetTypeName("Workflows$TimerBoundaryEvent") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.isInterrupting = property.NewPrimitive[bool]("IsInterrupting", property.DecodeBool) + o.isInterrupting.Bind(&o.Base, 4) + o.eventType = property.NewPrimitive[string]("EventType", property.DecodeString) + o.eventType.Bind(&o.Base, 5) + o.delay = property.NewPrimitive[string]("Delay", property.DecodeString) + o.delay.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.persistentId, o.flow, o.caption, o.annotation, o.isInterrupting, o.eventType, o.delay, }) + return o +} + +// NewTimerBoundaryEvent creates a new TimerBoundaryEvent for user code. Marked dirty (bit 63 = new element). +func NewTimerBoundaryEvent() *TimerBoundaryEvent { + o := initTimerBoundaryEvent() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUserTask creates a UserTask with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUserTask() *UserTask { + o := &UserTask{} + o.SetTypeName("Workflows$UserTask") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.userTaskEntity = property.NewByNameRef[element.Element]("UserTaskEntity", "DomainModels$Entity") + o.userTaskEntity.Bind(&o.Base, 6) + o.page = property.NewByNameRef[element.Element]("Page", "Forms$Page") + o.page.Bind(&o.Base, 7) + o.taskPage = property.NewPart[element.Element]("TaskPage") + o.taskPage.Bind(&o.Base, 8) + o.taskName = property.NewPart[element.Element]("TaskName") + o.taskName.Bind(&o.Base, 9) + o.taskDescription = property.NewPart[element.Element]("TaskDescription") + o.taskDescription.Bind(&o.Base, 10) + o.dueDate = property.NewPrimitive[string]("DueDate", property.DecodeString) + o.dueDate.Bind(&o.Base, 11) + o.userSource = property.NewPart[element.Element]("UserSource") + o.userSource.Bind(&o.Base, 12) + o.outcomes = property.NewPartList[element.Element]("Outcomes") + o.outcomes.Bind(&o.Base, 13) + o.allowedModuleRoles = property.NewByNameRefList[element.Element]("AllowedModuleRoles", "Security$ModuleRole") + o.allowedModuleRoles.Bind(&o.Base, 14) + o.onCreatedEvent = property.NewPart[element.Element]("OnCreatedEvent") + o.onCreatedEvent.Bind(&o.Base, 15) + o.autoAssignSingleTargetUser = property.NewPrimitive[bool]("AutoAssignSingleTargetUser", property.DecodeBool) + o.autoAssignSingleTargetUser.Bind(&o.Base, 16) + o.userTaskCompletion = property.NewPart[element.Element]("UserTaskCompletion") + o.userTaskCompletion.Bind(&o.Base, 17) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.userTaskEntity, o.page, o.taskPage, o.taskName, o.taskDescription, o.dueDate, o.userSource, o.outcomes, o.allowedModuleRoles, o.onCreatedEvent, o.autoAssignSingleTargetUser, o.userTaskCompletion, }) + return o +} + +// NewUserTask creates a new UserTask for user code. Marked dirty (bit 63 = new element). +func NewUserTask() *UserTask { + o := initUserTask() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initUserTaskOutcome creates a UserTaskOutcome with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initUserTaskOutcome() *UserTaskOutcome { + o := &UserTaskOutcome{} + o.SetTypeName("Workflows$UserTaskOutcome") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 1) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 2) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 3) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.persistentId, o.flow, o.name, o.caption, o.value, }) + return o +} + +// NewUserTaskOutcome creates a new UserTaskOutcome for user code. Marked dirty (bit 63 = new element). +func NewUserTaskOutcome() *UserTaskOutcome { + o := initUserTaskOutcome() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initVetoCompletionCriteria creates a VetoCompletionCriteria with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initVetoCompletionCriteria() *VetoCompletionCriteria { + o := &VetoCompletionCriteria{} + o.SetTypeName("Workflows$VetoCompletionCriteria") + o.vetoOutcome = property.NewByIdRef[element.Element]("VetoOutcomePointer") + o.vetoOutcome.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.vetoOutcome, }) + return o +} + +// NewVetoCompletionCriteria creates a new VetoCompletionCriteria for user code. Marked dirty (bit 63 = new element). +func NewVetoCompletionCriteria() *VetoCompletionCriteria { + o := initVetoCompletionCriteria() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initVoidCase creates a VoidCase with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initVoidCase() *VoidCase { + o := &VoidCase{} + o.SetTypeName("Workflows$VoidCase") + o.SetProperties([]element.Property{}) + return o +} + +// NewVoidCase creates a new VoidCase for user code. Marked dirty (bit 63 = new element). +func NewVoidCase() *VoidCase { + o := initVoidCase() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initVoidConditionOutcome creates a VoidConditionOutcome with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initVoidConditionOutcome() *VoidConditionOutcome { + o := &VoidConditionOutcome{} + o.SetTypeName("Workflows$VoidConditionOutcome") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.persistentId, o.flow, }) + return o +} + +// NewVoidConditionOutcome creates a new VoidConditionOutcome for user code. Marked dirty (bit 63 = new element). +func NewVoidConditionOutcome() *VoidConditionOutcome { + o := initVoidConditionOutcome() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWaitForNotificationActivity creates a WaitForNotificationActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWaitForNotificationActivity() *WaitForNotificationActivity { + o := &WaitForNotificationActivity{} + o.SetTypeName("Workflows$WaitForNotificationActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.boundaryEvents = property.NewPartList[element.Element]("BoundaryEvents") + o.boundaryEvents.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.boundaryEvents, }) + return o +} + +// NewWaitForNotificationActivity creates a new WaitForNotificationActivity for user code. Marked dirty (bit 63 = new element). +func NewWaitForNotificationActivity() *WaitForNotificationActivity { + o := initWaitForNotificationActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWaitForTimerActivity creates a WaitForTimerActivity with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWaitForTimerActivity() *WaitForTimerActivity { + o := &WaitForTimerActivity{} + o.SetTypeName("Workflows$WaitForTimerActivity") + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 0) + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 1) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 2) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 3) + o.relativeMiddlePoint = property.NewPrimitive[string]("RelativeMiddlePoint", property.DecodeString) + o.relativeMiddlePoint.Bind(&o.Base, 4) + o.size = property.NewPrimitive[string]("Size", property.DecodeString) + o.size.Bind(&o.Base, 5) + o.delay = property.NewPrimitive[string]("Delay", property.DecodeString) + o.delay.Bind(&o.Base, 6) + o.SetProperties([]element.Property{o.persistentId, o.name, o.caption, o.annotation, o.relativeMiddlePoint, o.size, o.delay, }) + return o +} + +// NewWaitForTimerActivity creates a new WaitForTimerActivity for user code. Marked dirty (bit 63 = new element). +func NewWaitForTimerActivity() *WaitForTimerActivity { + o := initWaitForTimerActivity() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflow creates a Workflow with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflow() *Workflow { + o := &Workflow{} + o.SetTypeName("Workflows$Workflow") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.persistentId = property.NewPrimitive[string]("PersistentId", property.DecodeString) + o.persistentId.Bind(&o.Base, 4) + o.title = property.NewPrimitive[string]("Title", property.DecodeString) + o.title.Bind(&o.Base, 5) + o.contextEntity = property.NewByNameRef[element.Element]("ContextEntity", "DomainModels$Entity") + o.contextEntity.Bind(&o.Base, 6) + o.parameter = property.NewPart[element.Element]("Parameter") + o.parameter.Bind(&o.Base, 7) + o.workflowEntity = property.NewByNameRef[element.Element]("WorkflowEntity", "DomainModels$Entity") + o.workflowEntity.Bind(&o.Base, 8) + o.workflowType = property.NewPart[element.Element]("WorkflowType") + o.workflowType.Bind(&o.Base, 9) + o.overviewPage = property.NewByNameRef[element.Element]("OverviewPage", "Forms$Page") + o.overviewPage.Bind(&o.Base, 10) + o.adminPage = property.NewPart[element.Element]("AdminPage") + o.adminPage.Bind(&o.Base, 11) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 12) + o.workflowName = property.NewPart[element.Element]("WorkflowName") + o.workflowName.Bind(&o.Base, 13) + o.workflowDescription = property.NewPart[element.Element]("WorkflowDescription") + o.workflowDescription.Bind(&o.Base, 14) + o.dueDate = property.NewPrimitive[string]("DueDate", property.DecodeString) + o.dueDate.Bind(&o.Base, 15) + o.allowedModuleRoles = property.NewByNameRefList[element.Element]("AllowedModuleRoles", "Security$ModuleRole") + o.allowedModuleRoles.Bind(&o.Base, 16) + o.workflowOnStateChangeEvent = property.NewPart[element.Element]("WorkflowOnStateChangeEvent") + o.workflowOnStateChangeEvent.Bind(&o.Base, 17) + o.usertaskOnStateChangeEvent = property.NewPart[element.Element]("UsertaskOnStateChangeEvent") + o.usertaskOnStateChangeEvent.Bind(&o.Base, 18) + o.onWorkflowEvent = property.NewPartList[element.Element]("OnWorkflowEvent") + o.onWorkflowEvent.Bind(&o.Base, 19) + o.eventSubProcesses = property.NewPartList[element.Element]("EventSubProcesses") + o.eventSubProcesses.Bind(&o.Base, 20) + o.annotation = property.NewPart[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 21) + o.workflowMetaData = property.NewPart[element.Element]("WorkflowMetaData") + o.workflowMetaData.Bind(&o.Base, 22) + o.workflowV2 = property.NewPrimitive[bool]("WorkflowV2", property.DecodeBool) + o.workflowV2.Bind(&o.Base, 23) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.persistentId, o.title, o.contextEntity, o.parameter, o.workflowEntity, o.workflowType, o.overviewPage, o.adminPage, o.flow, o.workflowName, o.workflowDescription, o.dueDate, o.allowedModuleRoles, o.workflowOnStateChangeEvent, o.usertaskOnStateChangeEvent, o.onWorkflowEvent, o.eventSubProcesses, o.annotation, o.workflowMetaData, o.workflowV2, }) + return o +} + +// NewWorkflow creates a new Workflow for user code. Marked dirty (bit 63 = new element). +func NewWorkflow() *Workflow { + o := initWorkflow() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowCallParameterMapping creates a WorkflowCallParameterMapping with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowCallParameterMapping() *WorkflowCallParameterMapping { + o := &WorkflowCallParameterMapping{} + o.SetTypeName("Workflows$WorkflowCallParameterMapping") + o.parameter = property.NewByNameRef[element.Element]("Parameter", "Workflows$Parameter") + o.parameter.Bind(&o.Base, 0) + o.expression = property.NewPrimitive[string]("Expression", property.DecodeString) + o.expression.Bind(&o.Base, 1) + o.SetProperties([]element.Property{o.parameter, o.expression, }) + return o +} + +// NewWorkflowCallParameterMapping creates a new WorkflowCallParameterMapping for user code. Marked dirty (bit 63 = new element). +func NewWorkflowCallParameterMapping() *WorkflowCallParameterMapping { + o := initWorkflowCallParameterMapping() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowDefinitionNameSelection creates a WorkflowDefinitionNameSelection with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowDefinitionNameSelection() *WorkflowDefinitionNameSelection { + o := &WorkflowDefinitionNameSelection{} + o.SetTypeName("Workflows$WorkflowDefinitionNameSelection") + o.workflow = property.NewByNameRef[element.Element]("Workflow", "Workflows$Workflow") + o.workflow.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.workflow, }) + return o +} + +// NewWorkflowDefinitionNameSelection creates a new WorkflowDefinitionNameSelection for user code. Marked dirty (bit 63 = new element). +func NewWorkflowDefinitionNameSelection() *WorkflowDefinitionNameSelection { + o := initWorkflowDefinitionNameSelection() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowDefinitionObjectSelection creates a WorkflowDefinitionObjectSelection with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowDefinitionObjectSelection() *WorkflowDefinitionObjectSelection { + o := &WorkflowDefinitionObjectSelection{} + o.SetTypeName("Workflows$WorkflowDefinitionObjectSelection") + o.workflowDefinitionVariable = property.NewPrimitive[string]("WorkflowDefinitionVariable", property.DecodeString) + o.workflowDefinitionVariable.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.workflowDefinitionVariable, }) + return o +} + +// NewWorkflowDefinitionObjectSelection creates a new WorkflowDefinitionObjectSelection for user code. Marked dirty (bit 63 = new element). +func NewWorkflowDefinitionObjectSelection() *WorkflowDefinitionObjectSelection { + o := initWorkflowDefinitionObjectSelection() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowEventHandler creates a WorkflowEventHandler with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowEventHandler() *WorkflowEventHandler { + o := &WorkflowEventHandler{} + o.SetTypeName("Workflows$WorkflowEventHandler") + o.description = property.NewPrimitive[string]("Description", property.DecodeString) + o.description.Bind(&o.Base, 0) + o.microflowEventHandler = property.NewPart[element.Element]("MicroflowEventHandler") + o.microflowEventHandler.Bind(&o.Base, 1) + o.eventTypes = property.NewEnumList[string]("EventTypes") + o.eventTypes.Bind(&o.Base, 2) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.description, o.microflowEventHandler, o.eventTypes, o.documentation, }) + return o +} + +// NewWorkflowEventHandler creates a new WorkflowEventHandler for user code. Marked dirty (bit 63 = new element). +func NewWorkflowEventHandler() *WorkflowEventHandler { + o := initWorkflowEventHandler() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowMetaData creates a WorkflowMetaData with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowMetaData() *WorkflowMetaData { + o := &WorkflowMetaData{} + o.SetTypeName("Workflows$WorkflowMetaData") + o.detachedActivities = property.NewPartList[element.Element]("DetachedActivities") + o.detachedActivities.Bind(&o.Base, 0) + o.flowLines = property.NewPartList[element.Element]("FlowLines") + o.flowLines.Bind(&o.Base, 1) + o.annotation = property.NewPartList[element.Element]("Annotation") + o.annotation.Bind(&o.Base, 2) + o.SetProperties([]element.Property{o.detachedActivities, o.flowLines, o.annotation, }) + return o +} + +// NewWorkflowMetaData creates a new WorkflowMetaData for user code. Marked dirty (bit 63 = new element). +func NewWorkflowMetaData() *WorkflowMetaData { + o := initWorkflowMetaData() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initWorkflowType creates a WorkflowType with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initWorkflowType() *WorkflowType { + o := &WorkflowType{} + o.SetTypeName("Workflows$WorkflowType") + o.entity = property.NewByNameRef[element.Element]("Entity", "DomainModels$Entity") + o.entity.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.entity, }) + return o +} + +// NewWorkflowType creates a new WorkflowType for user code. Marked dirty (bit 63 = new element). +func NewWorkflowType() *WorkflowType { + o := initWorkflowType() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initXPathBasedUserSource creates a XPathBasedUserSource with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initXPathBasedUserSource() *XPathBasedUserSource { + o := &XPathBasedUserSource{} + o.SetTypeName("Workflows$XPathBasedUserSource") + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.xPathConstraint, }) + return o +} + +// NewXPathBasedUserSource creates a new XPathBasedUserSource for user code. Marked dirty (bit 63 = new element). +func NewXPathBasedUserSource() *XPathBasedUserSource { + o := initXPathBasedUserSource() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initXPathGroupTargeting creates a XPathGroupTargeting with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initXPathGroupTargeting() *XPathGroupTargeting { + o := &XPathGroupTargeting{} + o.SetTypeName("Workflows$XPathGroupTargeting") + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.xPathConstraint, }) + return o +} + +// NewXPathGroupTargeting creates a new XPathGroupTargeting for user code. Marked dirty (bit 63 = new element). +func NewXPathGroupTargeting() *XPathGroupTargeting { + o := initXPathGroupTargeting() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initXPathUserTargeting creates a XPathUserTargeting with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initXPathUserTargeting() *XPathUserTargeting { + o := &XPathUserTargeting{} + o.SetTypeName("Workflows$XPathUserTargeting") + o.xPathConstraint = property.NewPrimitive[string]("XPathConstraint", property.DecodeString) + o.xPathConstraint.Bind(&o.Base, 0) + o.SetProperties([]element.Property{o.xPathConstraint, }) + return o +} + +// NewXPathUserTargeting creates a new XPathUserTargeting for user code. Marked dirty (bit 63 = new element). +func NewXPathUserTargeting() *XPathUserTargeting { + o := initXPathUserTargeting() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initExclusiveSplitOutcome creates a ExclusiveSplitOutcome with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initExclusiveSplitOutcome() *ExclusiveSplitOutcome { + o := &ExclusiveSplitOutcome{} + o.SetTypeName("Workflows$ExclusiveSplitOutcome") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.caption = property.NewPrimitive[string]("Caption", property.DecodeString) + o.caption.Bind(&o.Base, 1) + o.value = property.NewPrimitive[string]("Value", property.DecodeString) + o.value.Bind(&o.Base, 2) + o.flow = property.NewPart[element.Element]("Flow") + o.flow.Bind(&o.Base, 3) + o.SetProperties([]element.Property{o.name, o.caption, o.value, o.flow, }) + return o +} + +// NewExclusiveSplitOutcome creates a new ExclusiveSplitOutcome for user code. Marked dirty (bit 63 = new element). +func NewExclusiveSplitOutcome() *ExclusiveSplitOutcome { + o := initExclusiveSplitOutcome() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + + +func init() { + codec.DefaultRegistry.Register("Workflows$AIAgentTaskActivity", func() element.Element { + return initAIAgentTaskActivity() + }) + codec.DefaultRegistry.Register("Workflows$AbsoluteAmountUserInput", func() element.Element { + return initAbsoluteAmountUserInput() + }) + codec.DefaultRegistry.Register("Workflows$AllUserInput", func() element.Element { + return initAllUserInput() + }) + codec.DefaultRegistry.Register("Workflows$Annotation", func() element.Element { + o := initAnnotation() + o.SetTypeName("Workflows$Annotation") + return o + }) + codec.DefaultRegistry.Register("Workflows$AnnotationActivity", func() element.Element { + return initAnnotation() + }) + codec.DefaultRegistry.Register("Workflows$BezierCurve", func() element.Element { + return initBezierCurve() + }) + codec.DefaultRegistry.Register("Workflows$BooleanCase", func() element.Element { + return initBooleanCase() + }) + codec.DefaultRegistry.Register("Workflows$BooleanConditionOutcome", func() element.Element { + return initBooleanConditionOutcome() + }) + codec.DefaultRegistry.Register("Workflows$BoundaryEvent", func() element.Element { + return initBoundaryEvent() + }) + codec.DefaultRegistry.Register("Workflows$CallMicroflowActivity", func() element.Element { + return initCallMicroflowActivity() + }) + codec.DefaultRegistry.Register("Workflows$CallMicroflowTask", func() element.Element { + return initCallMicroflowTask() + }) + codec.DefaultRegistry.Register("Workflows$CallWorkflowActivity", func() element.Element { + return initCallWorkflowActivity() + }) + codec.DefaultRegistry.Register("Workflows$ConsensusCompletionCriteria", func() element.Element { + return initConsensusCompletionCriteria() + }) + codec.DefaultRegistry.Register("Workflows$EmptyUserSource", func() element.Element { + return initEmptyUserSource() + }) + codec.DefaultRegistry.Register("Workflows$EndOfBoundaryEventPathActivity", func() element.Element { + return initEndOfBoundaryEventPathActivity() + }) + codec.DefaultRegistry.Register("Workflows$EndOfParallelSplitPathActivity", func() element.Element { + return initEndOfParallelSplitPathActivity() + }) + codec.DefaultRegistry.Register("Workflows$EndWorkflowActivity", func() element.Element { + return initEndWorkflowActivity() + }) + codec.DefaultRegistry.Register("Workflows$EnumerationValueConditionOutcome", func() element.Element { + return initEnumerationValueConditionOutcome() + }) + codec.DefaultRegistry.Register("Workflows$EventSubProcess", func() element.Element { + return initEventSubProcess() + }) + codec.DefaultRegistry.Register("Workflows$ExclusiveSplitActivity", func() element.Element { + return initExclusiveSplitActivity() + }) + codec.DefaultRegistry.Register("Workflows$FloatingAnnotation", func() element.Element { + return initFloatingAnnotation() + }) + codec.DefaultRegistry.Register("Workflows$Flow", func() element.Element { + return initFlow() + }) + codec.DefaultRegistry.Register("Workflows$FlowLine", func() element.Element { + return initFlowLine() + }) + codec.DefaultRegistry.Register("Workflows$InterruptingTimerBoundaryEvent", func() element.Element { + return initInterruptingTimerBoundaryEvent() + }) + codec.DefaultRegistry.Register("Workflows$JumpToActivity", func() element.Element { + return initJumpToActivity() + }) + codec.DefaultRegistry.Register("Workflows$LinearRecurrence", func() element.Element { + return initLinearRecurrence() + }) + codec.DefaultRegistry.Register("Workflows$MajorityCompletionCriteria", func() element.Element { + return initMajorityCompletionCriteria() + }) + codec.DefaultRegistry.Register("Workflows$MergeActivity", func() element.Element { + return initMergeActivity() + }) + codec.DefaultRegistry.Register("Workflows$MicroflowBasedEvent", func() element.Element { + return initMicroflowBasedEvent() + }) + codec.DefaultRegistry.Register("Workflows$MicroflowBasedUserSource", func() element.Element { + return initMicroflowBasedUserSource() + }) + codec.DefaultRegistry.Register("Workflows$MicroflowCallParameterMapping", func() element.Element { + return initMicroflowCallParameterMapping() + }) + codec.DefaultRegistry.Register("Workflows$MicroflowCompletionCriteria", func() element.Element { + return initMicroflowCompletionCriteria() + }) + codec.DefaultRegistry.Register("Workflows$MicroflowEventHandler", func() element.Element { + return initMicroflowEventHandler() + }) + codec.DefaultRegistry.Register("Workflows$MicroflowGroupTargeting", func() element.Element { + return initMicroflowGroupTargeting() + }) + codec.DefaultRegistry.Register("Workflows$MicroflowUserTargeting", func() element.Element { + return initMicroflowUserTargeting() + }) + codec.DefaultRegistry.Register("Workflows$MultiInputCompletion", func() element.Element { + return initMultiInputCompletion() + }) + codec.DefaultRegistry.Register("Workflows$MultiUserTaskActivity", func() element.Element { + return initMultiUserTaskActivity() + }) + codec.DefaultRegistry.Register("Workflows$NoEvent", func() element.Element { + return initNoEvent() + }) + codec.DefaultRegistry.Register("Workflows$NoUserTargeting", func() element.Element { + return initNoUserTargeting() + }) + codec.DefaultRegistry.Register("Workflows$NonInterruptingNotificationEventSubProcessStartActivity", func() element.Element { + return initNonInterruptingNotificationEventSubProcessStartActivity() + }) + codec.DefaultRegistry.Register("Workflows$NonInterruptingNotificationEventSubProcessStartActivityTarget", func() element.Element { + return initNonInterruptingNotificationEventSubProcessStartActivityTarget() + }) + codec.DefaultRegistry.Register("Workflows$NonInterruptingTimerBoundaryEvent", func() element.Element { + return initNonInterruptingTimerBoundaryEvent() + }) + codec.DefaultRegistry.Register("Workflows$NotifyWaitForNotificationActivityTarget", func() element.Element { + return initNotifyWaitForNotificationActivityTarget() + }) + codec.DefaultRegistry.Register("Workflows$OrthogonalPath", func() element.Element { + return initOrthogonalPath() + }) + codec.DefaultRegistry.Register("Workflows$PageParameterMapping", func() element.Element { + return initPageParameterMapping() + }) + codec.DefaultRegistry.Register("Workflows$PageReference", func() element.Element { + return initPageReference() + }) + codec.DefaultRegistry.Register("Workflows$ParallelSplitActivity", func() element.Element { + return initParallelSplitActivity() + }) + codec.DefaultRegistry.Register("Workflows$ParallelSplitOutcome", func() element.Element { + return initParallelSplitOutcome() + }) + codec.DefaultRegistry.Register("Workflows$Parameter", func() element.Element { + return initParameter() + }) + codec.DefaultRegistry.Register("Workflows$PercentageAmountUserInput", func() element.Element { + return initPercentageAmountUserInput() + }) + codec.DefaultRegistry.Register("Workflows$SingleInputCompletion", func() element.Element { + return initSingleInputCompletion() + }) + codec.DefaultRegistry.Register("Workflows$SingleUserTaskActivity", func() element.Element { + return initSingleUserTaskActivity() + }) + codec.DefaultRegistry.Register("Workflows$StartWorkflowActivity", func() element.Element { + return initStartWorkflowActivity() + }) + codec.DefaultRegistry.Register("Workflows$StringCase", func() element.Element { + return initStringCase() + }) + codec.DefaultRegistry.Register("Workflows$ThresholdCompletionCriteria", func() element.Element { + return initThresholdCompletionCriteria() + }) + codec.DefaultRegistry.Register("Workflows$TimerBoundaryEvent", func() element.Element { + return initTimerBoundaryEvent() + }) + codec.DefaultRegistry.Register("Workflows$UserTask", func() element.Element { + return initUserTask() + }) + codec.DefaultRegistry.Register("Workflows$UserTaskOutcome", func() element.Element { + return initUserTaskOutcome() + }) + codec.DefaultRegistry.Register("Workflows$VetoCompletionCriteria", func() element.Element { + return initVetoCompletionCriteria() + }) + codec.DefaultRegistry.Register("Workflows$VoidCase", func() element.Element { + return initVoidCase() + }) + codec.DefaultRegistry.Register("Workflows$VoidConditionOutcome", func() element.Element { + return initVoidConditionOutcome() + }) + codec.DefaultRegistry.Register("Workflows$WaitForNotificationActivity", func() element.Element { + return initWaitForNotificationActivity() + }) + codec.DefaultRegistry.Register("Workflows$WaitForTimerActivity", func() element.Element { + return initWaitForTimerActivity() + }) + codec.DefaultRegistry.Register("Workflows$Workflow", func() element.Element { + return initWorkflow() + }) + codec.DefaultRegistry.Register("Workflows$WorkflowCallParameterMapping", func() element.Element { + return initWorkflowCallParameterMapping() + }) + codec.DefaultRegistry.Register("Workflows$WorkflowDefinitionNameSelection", func() element.Element { + return initWorkflowDefinitionNameSelection() + }) + codec.DefaultRegistry.Register("Workflows$WorkflowDefinitionObjectSelection", func() element.Element { + return initWorkflowDefinitionObjectSelection() + }) + codec.DefaultRegistry.Register("Workflows$WorkflowEventHandler", func() element.Element { + return initWorkflowEventHandler() + }) + codec.DefaultRegistry.Register("Workflows$WorkflowMetaData", func() element.Element { + return initWorkflowMetaData() + }) + codec.DefaultRegistry.Register("Workflows$WorkflowType", func() element.Element { + return initWorkflowType() + }) + codec.DefaultRegistry.Register("Workflows$XPathBasedUserSource", func() element.Element { + return initXPathBasedUserSource() + }) + codec.DefaultRegistry.Register("Workflows$XPathGroupTargeting", func() element.Element { + return initXPathGroupTargeting() + }) + codec.DefaultRegistry.Register("Workflows$XPathUserTargeting", func() element.Element { + return initXPathUserTargeting() + }) + codec.DefaultRegistry.Register("Workflows$ExclusiveSplitOutcome", func() element.Element { + return initExclusiveSplitOutcome() + }) +} diff --git a/modelsdk/gen/workflows/version.go b/modelsdk/gen/workflows/version.go new file mode 100644 index 00000000..bb7108bb --- /dev/null +++ b/modelsdk/gen/workflows/version.go @@ -0,0 +1,241 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package workflows + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{ + "Workflows$WorkflowActivity": { + Properties: map[string]version.PropertyVersionInfo{ + "annotation": {Introduced: "9.15.0"}, + "caption": {Public: true}, + "name": {Introduced: "9.0.5", Public: true}, + "persistentId": {Introduced: "10.21.0"}, + "relativeMiddlePoint": {Introduced: "11.1.0"}, + "size": {Introduced: "11.1.0"}, + }, + }, + "Workflows$ConditionOutcomeActivity": { + Properties: map[string]version.PropertyVersionInfo{ + "outcomes": {Public: true}, + }, + }, + "Workflows$MicroflowBasedActivity": { + Properties: map[string]version.PropertyVersionInfo{ + "boundaryEvents": {Public: true}, + "microflow": {Public: true}, + }, + }, + "Workflows$AbsoluteAmountUserInput": { + Properties: map[string]version.PropertyVersionInfo{ + "amount": {}, + }, + }, + "Workflows$Outcome": { + Properties: map[string]version.PropertyVersionInfo{ + "flow": {Required: true, Public: true}, + "persistentId": {Introduced: "10.21.0"}, + }, + }, + "Workflows$BooleanConditionOutcome": { + Properties: map[string]version.PropertyVersionInfo{ + "value": {Public: true}, + }, + }, + "Workflows$BoundaryEvent": { + Properties: map[string]version.PropertyVersionInfo{ + "annotation": {Introduced: "10.16.0"}, + "caption": {Public: true}, + "flow": {Required: true, Public: true}, + "isInterrupting": {Introduced: "10.17.0", Deleted: "10.20.0", Public: true}, + "persistentId": {Introduced: "10.21.0"}, + }, + }, + "Workflows$CallMicroflowTask": { + Properties: map[string]version.PropertyVersionInfo{ + "boundaryEvents": {Introduced: "10.14.0", Public: true}, + "microflow": {Public: true}, + }, + }, + "Workflows$CallWorkflowActivity": { + Properties: map[string]version.PropertyVersionInfo{ + "boundaryEvents": {Introduced: "10.14.0", Public: true}, + "executeAsync": {Introduced: "9.18.0"}, + "parameterExpression": {Introduced: "9.6.0", Deleted: "9.18.0"}, + "parameterMappings": {Introduced: "9.18.0"}, + "workflow": {Public: true}, + }, + }, + "Workflows$EnumerationValueConditionOutcome": { + Properties: map[string]version.PropertyVersionInfo{ + "value": {Public: true}, + }, + }, + "Workflows$EventSubProcess": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Public: true}, + "flow": {Required: true, Public: true}, + "name": {Public: true}, + }, + }, + "Workflows$Flow": { + Properties: map[string]version.PropertyVersionInfo{ + "activities": {Public: true}, + }, + }, + "Workflows$FlowLine": { + Properties: map[string]version.PropertyVersionInfo{ + "caseValues": {Introduced: "11.5.0"}, + "destination": {Required: true}, + "line": {Required: true}, + "origin": {Required: true}, + }, + }, + "Workflows$LinearRecurrence": { + Properties: map[string]version.PropertyVersionInfo{ + "interval": {Public: true}, + "intervalType": {Public: true}, + "maxExecutions": {Public: true}, + }, + }, + "Workflows$MicroflowCallParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true}, + }, + }, + "Workflows$MultiInputCompletion": { + Properties: map[string]version.PropertyVersionInfo{ + "awaitAllUsers": {Introduced: "10.2.0"}, + "completionCriteria": {Required: true}, + "targetUserInput": {Required: true}, + }, + }, + "Workflows$UserTaskActivity": { + Properties: map[string]version.PropertyVersionInfo{ + "boundaryEvents": {Introduced: "10.14.0", Public: true}, + "onCreatedEvent": {Required: true}, + "outcomes": {Public: true}, + "taskDescription": {Required: true}, + "taskName": {Required: true}, + "taskPage": {Required: true, Public: true}, + "userSource": {Deleted: "11.2.0", Required: true}, + "userTargeting": {Introduced: "11.2.0", Required: true}, + }, + }, + "Workflows$MultiUserTaskActivity": { + Properties: map[string]version.PropertyVersionInfo{ + "completionCriteria": {Required: true}, + "targetUserInput": {Required: true}, + }, + }, + "Workflows$NonInterruptingNotificationEventSubProcessStartActivityTarget": { + Properties: map[string]version.PropertyVersionInfo{ + "activity": {Required: true}, + }, + }, + "Workflows$NonInterruptingTimerBoundaryEvent": { + Properties: map[string]version.PropertyVersionInfo{ + "recurrence": {Public: true}, + }, + }, + "Workflows$NotifyWaitForNotificationActivityTarget": { + Properties: map[string]version.PropertyVersionInfo{ + "activity": {Required: true}, + }, + }, + "Workflows$PageParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true}, + }, + }, + "Workflows$PageReference": { + Properties: map[string]version.PropertyVersionInfo{ + "page": {Public: true}, + }, + }, + "Workflows$ParallelSplitActivity": { + Properties: map[string]version.PropertyVersionInfo{ + "outcomes": {Public: true}, + }, + }, + "Workflows$Parameter": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Introduced: "9.10.0", Public: true}, + "entityRef": {Deleted: "9.10.0", Public: true}, + "name": {Introduced: "9.18.0", Public: true}, + }, + }, + "Workflows$PercentageAmountUserInput": { + Properties: map[string]version.PropertyVersionInfo{ + "percentage": {}, + }, + }, + "Workflows$UserTask": { + Properties: map[string]version.PropertyVersionInfo{ + "allowedModuleRoles": {Introduced: "9.0.3", Deleted: "9.6.0", Public: true}, + "autoAssignSingleTargetUser": {Introduced: "9.11.0"}, + "onCreatedEvent": {Introduced: "9.0.5", Required: true}, + "outcomes": {Public: true}, + "page": {Deleted: "9.11.0", Public: true}, + "taskDescription": {Required: true}, + "taskName": {Required: true}, + "taskPage": {Introduced: "9.11.0", Required: true, Public: true}, + "userSource": {Required: true}, + "userTaskCompletion": {Introduced: "9.22.0", Required: true}, + "userTaskEntity": {Introduced: "9.6.0", Deleted: "9.10.0", Public: true}, + }, + }, + "Workflows$UserTaskOutcome": { + Properties: map[string]version.PropertyVersionInfo{ + "caption": {Deleted: "9.19.0", Public: true}, + "name": {Deleted: "9.19.0", Public: true}, + "value": {Introduced: "9.19.0", Public: true}, + }, + }, + "Workflows$WaitForNotificationActivity": { + Properties: map[string]version.PropertyVersionInfo{ + "boundaryEvents": {Introduced: "10.14.0", Public: true}, + }, + }, + "Workflows$Workflow": { + Properties: map[string]version.PropertyVersionInfo{ + "adminPage": {Introduced: "9.11.0"}, + "allowedModuleRoles": {Deleted: "9.6.0", Public: true}, + "annotation": {Introduced: "9.15.0"}, + "contextEntity": {Deleted: "9.6.0", Public: true}, + "eventSubProcesses": {Introduced: "11.8.0"}, + "flow": {Required: true, Public: true}, + "onWorkflowEvent": {Introduced: "10.7.0"}, + "overviewPage": {Deleted: "9.11.0", Public: true}, + "parameter": {Introduced: "9.6.0", Required: true, Public: true}, + "persistentId": {Introduced: "10.21.0"}, + "title": {Public: true}, + "usertaskOnStateChangeEvent": {Introduced: "9.12.0", Deleted: "11.0.0"}, + "workflowDescription": {Required: true}, + "workflowEntity": {Introduced: "9.6.0", Deleted: "9.7.0", Public: true}, + "workflowMetaData": {Introduced: "11.1.0"}, + "workflowName": {Required: true}, + "workflowOnStateChangeEvent": {Introduced: "9.12.0", Deleted: "11.0.0"}, + "workflowType": {Introduced: "9.7.0", Deleted: "9.10.0", Required: true, Public: true}, + "workflowV2": {Introduced: "11.1.0"}, + }, + }, + "Workflows$WorkflowCallParameterMapping": { + Properties: map[string]version.PropertyVersionInfo{ + "parameter": {Required: true}, + }, + }, + "Workflows$WorkflowDefinitionNameSelection": { + Properties: map[string]version.PropertyVersionInfo{ + "workflow": {Required: true}, + }, + }, + "Workflows$WorkflowType": { + Properties: map[string]version.PropertyVersionInfo{ + "entity": {Public: true}, + }, + }, +} diff --git a/modelsdk/gen/xmlschemas/enums.go b/modelsdk/gen/xmlschemas/enums.go new file mode 100644 index 00000000..d439c6f7 --- /dev/null +++ b/modelsdk/gen/xmlschemas/enums.go @@ -0,0 +1,23 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package xmlschemas + +// XmlPrimitiveType enumerates the possible values for the XmlPrimitiveType type. +type XmlPrimitiveType = string + +const ( + XmlPrimitiveTypeUnknown XmlPrimitiveType = "Unknown" + XmlPrimitiveTypeBoolean XmlPrimitiveType = "Boolean" + XmlPrimitiveTypeDate XmlPrimitiveType = "Date" + XmlPrimitiveTypeTime XmlPrimitiveType = "Time" + XmlPrimitiveTypeDateTime XmlPrimitiveType = "DateTime" + XmlPrimitiveTypeDecimal XmlPrimitiveType = "Decimal" + XmlPrimitiveTypeFloat XmlPrimitiveType = "Float" + XmlPrimitiveTypeInteger XmlPrimitiveType = "Integer" + XmlPrimitiveTypeLong XmlPrimitiveType = "Long" + XmlPrimitiveTypeBinary XmlPrimitiveType = "Binary" + XmlPrimitiveTypeString XmlPrimitiveType = "String" + XmlPrimitiveTypeAnyType XmlPrimitiveType = "AnyType" +) diff --git a/modelsdk/gen/xmlschemas/refs.go b/modelsdk/gen/xmlschemas/refs.go new file mode 100644 index 00000000..d64c99a7 --- /dev/null +++ b/modelsdk/gen/xmlschemas/refs.go @@ -0,0 +1,5 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package xmlschemas diff --git a/modelsdk/gen/xmlschemas/types.go b/modelsdk/gen/xmlschemas/types.go new file mode 100644 index 00000000..0a658597 --- /dev/null +++ b/modelsdk/gen/xmlschemas/types.go @@ -0,0 +1,592 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package xmlschemas + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "github.com/mendixlabs/mxcli/modelsdk/property" + "go.mongodb.org/mongo-driver/bson" +) + +// Ensure imports are used. +var ( + _ = codec.DefaultRegistry + _ element.Element = nil + _ = property.DecodeString + _ bson.Raw = nil +) + +// ──────────────────────────────────────────────────────── +// MxSchema +// ──────────────────────────────────────────────────────── + +type MxSchema struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] +} + +// Name returns the value of the name property. +func (o *MxSchema) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *MxSchema) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *MxSchema) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *MxSchema) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *MxSchema) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *MxSchema) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *MxSchema) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *MxSchema) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *MxSchema) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } +} + +// ──────────────────────────────────────────────────────── +// XmlElement +// ──────────────────────────────────────────────────────── + +type XmlElement struct { + element.Base + elementType *property.Enum[string] + primitiveType *property.Enum[string] + path *property.Primitive[string] + isDefaultType *property.Primitive[bool] + minOccurs *property.Primitive[int32] + maxOccurs *property.Primitive[int32] + nillable *property.Primitive[bool] + exposedName *property.Primitive[string] + exposedItemName *property.Primitive[string] + maxLength *property.Primitive[int32] + fractionDigits *property.Primitive[int32] + totalDigits *property.Primitive[int32] + errorMessage *property.Primitive[string] + warningMessage *property.Primitive[string] + children *property.PartList[element.Element] +} + +// ElementType returns the value of the elementType property. +func (o *XmlElement) ElementType() string { + return o.elementType.Get() +} + +// SetElementType sets the value of the elementType property. +func (o *XmlElement) SetElementType(v string) { + o.elementType.Set(v) +} + +// PrimitiveType returns the value of the primitiveType property. +func (o *XmlElement) PrimitiveType() string { + return o.primitiveType.Get() +} + +// SetPrimitiveType sets the value of the primitiveType property. +func (o *XmlElement) SetPrimitiveType(v string) { + o.primitiveType.Set(v) +} + +// Path returns the value of the path property. +func (o *XmlElement) Path() string { + return o.path.Get() +} + +// SetPath sets the value of the path property. +func (o *XmlElement) SetPath(v string) { + o.path.Set(v) +} + +// IsDefaultType returns the value of the isDefaultType property. +func (o *XmlElement) IsDefaultType() bool { + return o.isDefaultType.Get() +} + +// SetIsDefaultType sets the value of the isDefaultType property. +func (o *XmlElement) SetIsDefaultType(v bool) { + o.isDefaultType.Set(v) +} + +// MinOccurs returns the value of the minOccurs property. +func (o *XmlElement) MinOccurs() int32 { + return o.minOccurs.Get() +} + +// SetMinOccurs sets the value of the minOccurs property. +func (o *XmlElement) SetMinOccurs(v int32) { + o.minOccurs.Set(v) +} + +// MaxOccurs returns the value of the maxOccurs property. +func (o *XmlElement) MaxOccurs() int32 { + return o.maxOccurs.Get() +} + +// SetMaxOccurs sets the value of the maxOccurs property. +func (o *XmlElement) SetMaxOccurs(v int32) { + o.maxOccurs.Set(v) +} + +// Nillable returns the value of the nillable property. +func (o *XmlElement) Nillable() bool { + return o.nillable.Get() +} + +// SetNillable sets the value of the nillable property. +func (o *XmlElement) SetNillable(v bool) { + o.nillable.Set(v) +} + +// ExposedName returns the value of the exposedName property. +func (o *XmlElement) ExposedName() string { + return o.exposedName.Get() +} + +// SetExposedName sets the value of the exposedName property. +func (o *XmlElement) SetExposedName(v string) { + o.exposedName.Set(v) +} + +// ExposedItemName returns the value of the exposedItemName property. +func (o *XmlElement) ExposedItemName() string { + return o.exposedItemName.Get() +} + +// SetExposedItemName sets the value of the exposedItemName property. +func (o *XmlElement) SetExposedItemName(v string) { + o.exposedItemName.Set(v) +} + +// MaxLength returns the value of the maxLength property. +func (o *XmlElement) MaxLength() int32 { + return o.maxLength.Get() +} + +// SetMaxLength sets the value of the maxLength property. +func (o *XmlElement) SetMaxLength(v int32) { + o.maxLength.Set(v) +} + +// FractionDigits returns the value of the fractionDigits property. +func (o *XmlElement) FractionDigits() int32 { + return o.fractionDigits.Get() +} + +// SetFractionDigits sets the value of the fractionDigits property. +func (o *XmlElement) SetFractionDigits(v int32) { + o.fractionDigits.Set(v) +} + +// TotalDigits returns the value of the totalDigits property. +func (o *XmlElement) TotalDigits() int32 { + return o.totalDigits.Get() +} + +// SetTotalDigits sets the value of the totalDigits property. +func (o *XmlElement) SetTotalDigits(v int32) { + o.totalDigits.Set(v) +} + +// ErrorMessage returns the value of the errorMessage property. +func (o *XmlElement) ErrorMessage() string { + return o.errorMessage.Get() +} + +// SetErrorMessage sets the value of the errorMessage property. +func (o *XmlElement) SetErrorMessage(v string) { + o.errorMessage.Set(v) +} + +// WarningMessage returns the value of the warningMessage property. +func (o *XmlElement) WarningMessage() string { + return o.warningMessage.Get() +} + +// SetWarningMessage sets the value of the warningMessage property. +func (o *XmlElement) SetWarningMessage(v string) { + o.warningMessage.Set(v) +} + +// ChildrenItems returns the value of the children property. +func (o *XmlElement) ChildrenItems() []element.Element { + return o.children.Items() +} + +// AddChildren appends a child element to the children list. +func (o *XmlElement) AddChildren(v element.Element) { + o.children.Append(v) +} + +// RemoveChildren removes the element at the given index from the children list. +func (o *XmlElement) RemoveChildren(index int) { + o.children.Remove(index) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *XmlElement) InitFromRaw(raw bson.Raw) { + if val, err := raw.LookupErr("ElementType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.elementType.SetFromDecode(s) + } + } + if val, err := raw.LookupErr("PrimitiveType"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.primitiveType.SetFromDecode(s) + } + } + o.path.Init(raw) + o.isDefaultType.Init(raw) + o.minOccurs.Init(raw) + o.maxOccurs.Init(raw) + o.nillable.Init(raw) + o.exposedName.Init(raw) + o.exposedItemName.Init(raw) + o.maxLength.Init(raw) + o.fractionDigits.Init(raw) + o.totalDigits.Init(raw) + o.errorMessage.Init(raw) + o.warningMessage.Init(raw) + if children, err := codec.DecodeChildren(raw, "Children"); err == nil { + for _, child := range children { + o.children.AppendFromDecode(child) + } + } +} + +// ──────────────────────────────────────────────────────── +// XmlSchema +// ──────────────────────────────────────────────────────── + +type XmlSchema struct { + element.Base + name *property.Primitive[string] + documentation *property.Primitive[string] + excluded *property.Primitive[bool] + exportLevel *property.Enum[string] + entries *property.PartList[element.Element] + filePath *property.Primitive[string] +} + +// Name returns the value of the name property. +func (o *XmlSchema) Name() string { + return o.name.Get() +} + +// SetName sets the value of the name property. +func (o *XmlSchema) SetName(v string) { + o.name.Set(v) +} + +// Documentation returns the value of the documentation property. +func (o *XmlSchema) Documentation() string { + return o.documentation.Get() +} + +// SetDocumentation sets the value of the documentation property. +func (o *XmlSchema) SetDocumentation(v string) { + o.documentation.Set(v) +} + +// Excluded returns the value of the excluded property. +func (o *XmlSchema) Excluded() bool { + return o.excluded.Get() +} + +// SetExcluded sets the value of the excluded property. +func (o *XmlSchema) SetExcluded(v bool) { + o.excluded.Set(v) +} + +// ExportLevel returns the value of the exportLevel property. +func (o *XmlSchema) ExportLevel() string { + return o.exportLevel.Get() +} + +// SetExportLevel sets the value of the exportLevel property. +func (o *XmlSchema) SetExportLevel(v string) { + o.exportLevel.Set(v) +} + +// EntriesItems returns the value of the entries property. +func (o *XmlSchema) EntriesItems() []element.Element { + return o.entries.Items() +} + +// AddEntries appends a child element to the entries list. +func (o *XmlSchema) AddEntries(v element.Element) { + o.entries.Append(v) +} + +// RemoveEntries removes the element at the given index from the entries list. +func (o *XmlSchema) RemoveEntries(index int) { + o.entries.Remove(index) +} + +// FilePath returns the value of the filePath property. +func (o *XmlSchema) FilePath() string { + return o.filePath.Get() +} + +// SetFilePath sets the value of the filePath property. +func (o *XmlSchema) SetFilePath(v string) { + o.filePath.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *XmlSchema) InitFromRaw(raw bson.Raw) { + o.name.Init(raw) + o.documentation.Init(raw) + o.excluded.Init(raw) + if val, err := raw.LookupErr("ExportLevel"); err == nil { + if s, ok := val.StringValueOK(); ok { + o.exportLevel.SetFromDecode(s) + } + } + if children, err := codec.DecodeChildren(raw, "Entries"); err == nil { + for _, child := range children { + o.entries.AppendFromDecode(child) + } + } + o.filePath.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// XmlSchemaEntry +// ──────────────────────────────────────────────────────── + +type XmlSchemaEntry struct { + element.Base + targetNamespace *property.Primitive[string] + location *property.Primitive[string] + contents *property.Primitive[string] + localizedLocationFormat *property.Primitive[string] + localizedContentsFormat *property.Primitive[string] +} + +// TargetNamespace returns the value of the targetNamespace property. +func (o *XmlSchemaEntry) TargetNamespace() string { + return o.targetNamespace.Get() +} + +// SetTargetNamespace sets the value of the targetNamespace property. +func (o *XmlSchemaEntry) SetTargetNamespace(v string) { + o.targetNamespace.Set(v) +} + +// Location returns the value of the location property. +func (o *XmlSchemaEntry) Location() string { + return o.location.Get() +} + +// SetLocation sets the value of the location property. +func (o *XmlSchemaEntry) SetLocation(v string) { + o.location.Set(v) +} + +// Contents returns the value of the contents property. +func (o *XmlSchemaEntry) Contents() string { + return o.contents.Get() +} + +// SetContents sets the value of the contents property. +func (o *XmlSchemaEntry) SetContents(v string) { + o.contents.Set(v) +} + +// LocalizedLocationFormat returns the value of the localizedLocationFormat property. +func (o *XmlSchemaEntry) LocalizedLocationFormat() string { + return o.localizedLocationFormat.Get() +} + +// SetLocalizedLocationFormat sets the value of the localizedLocationFormat property. +func (o *XmlSchemaEntry) SetLocalizedLocationFormat(v string) { + o.localizedLocationFormat.Set(v) +} + +// LocalizedContentsFormat returns the value of the localizedContentsFormat property. +func (o *XmlSchemaEntry) LocalizedContentsFormat() string { + return o.localizedContentsFormat.Get() +} + +// SetLocalizedContentsFormat sets the value of the localizedContentsFormat property. +func (o *XmlSchemaEntry) SetLocalizedContentsFormat(v string) { + o.localizedContentsFormat.Set(v) +} + +// InitFromRaw populates lazy-decoded property holders from raw BSON. +func (o *XmlSchemaEntry) InitFromRaw(raw bson.Raw) { + o.targetNamespace.Init(raw) + o.location.Init(raw) + o.contents.Init(raw) + o.localizedLocationFormat.Init(raw) + o.localizedContentsFormat.Init(raw) +} + +// ──────────────────────────────────────────────────────── +// Factory functions +// ──────────────────────────────────────────────────────── + +// initXmlElement creates a XmlElement with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initXmlElement() *XmlElement { + o := &XmlElement{} + o.SetTypeName("XmlSchemas$XmlSchemaContents") + o.elementType = property.NewEnum[string]("ElementType") + o.elementType.Bind(&o.Base, 0) + o.primitiveType = property.NewEnum[string]("PrimitiveType") + o.primitiveType.Bind(&o.Base, 1) + o.path = property.NewPrimitive[string]("Path", property.DecodeString) + o.path.Bind(&o.Base, 2) + o.isDefaultType = property.NewPrimitive[bool]("IsDefaultType", property.DecodeBool) + o.isDefaultType.Bind(&o.Base, 3) + o.minOccurs = property.NewPrimitive[int32]("MinOccurs", property.DecodeInt32) + o.minOccurs.Bind(&o.Base, 4) + o.maxOccurs = property.NewPrimitive[int32]("MaxOccurs", property.DecodeInt32) + o.maxOccurs.Bind(&o.Base, 5) + o.nillable = property.NewPrimitive[bool]("Nillable", property.DecodeBool) + o.nillable.Bind(&o.Base, 6) + o.exposedName = property.NewPrimitive[string]("ExposedName", property.DecodeString) + o.exposedName.Bind(&o.Base, 7) + o.exposedItemName = property.NewPrimitive[string]("ExposedItemName", property.DecodeString) + o.exposedItemName.Bind(&o.Base, 8) + o.maxLength = property.NewPrimitive[int32]("MaxLength", property.DecodeInt32) + o.maxLength.Bind(&o.Base, 9) + o.fractionDigits = property.NewPrimitive[int32]("FractionDigits", property.DecodeInt32) + o.fractionDigits.Bind(&o.Base, 10) + o.totalDigits = property.NewPrimitive[int32]("TotalDigits", property.DecodeInt32) + o.totalDigits.Bind(&o.Base, 11) + o.errorMessage = property.NewPrimitive[string]("ErrorMessage", property.DecodeString) + o.errorMessage.Bind(&o.Base, 12) + o.warningMessage = property.NewPrimitive[string]("WarningMessage", property.DecodeString) + o.warningMessage.Bind(&o.Base, 13) + o.children = property.NewPartList[element.Element]("Children") + o.children.Bind(&o.Base, 14) + o.SetProperties([]element.Property{o.elementType, o.primitiveType, o.path, o.isDefaultType, o.minOccurs, o.maxOccurs, o.nillable, o.exposedName, o.exposedItemName, o.maxLength, o.fractionDigits, o.totalDigits, o.errorMessage, o.warningMessage, o.children}) + return o +} + +// NewXmlElement creates a new XmlElement for user code. Marked dirty (bit 63 = new element). +func NewXmlElement() *XmlElement { + o := initXmlElement() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initXmlSchema creates a XmlSchema with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initXmlSchema() *XmlSchema { + o := &XmlSchema{} + o.SetTypeName("XmlSchemas$XmlSchema") + o.name = property.NewPrimitive[string]("Name", property.DecodeString) + o.name.Bind(&o.Base, 0) + o.documentation = property.NewPrimitive[string]("Documentation", property.DecodeString) + o.documentation.Bind(&o.Base, 1) + o.excluded = property.NewPrimitive[bool]("Excluded", property.DecodeBool) + o.excluded.Bind(&o.Base, 2) + o.exportLevel = property.NewEnum[string]("ExportLevel") + o.exportLevel.Bind(&o.Base, 3) + o.entries = property.NewPartList[element.Element]("Entries") + o.entries.Bind(&o.Base, 4) + o.filePath = property.NewPrimitive[string]("FilePath", property.DecodeString) + o.filePath.Bind(&o.Base, 5) + o.SetProperties([]element.Property{o.name, o.documentation, o.excluded, o.exportLevel, o.entries, o.filePath}) + return o +} + +// NewXmlSchema creates a new XmlSchema for user code. Marked dirty (bit 63 = new element). +func NewXmlSchema() *XmlSchema { + o := initXmlSchema() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +// initXmlSchemaEntry creates a XmlSchemaEntry with properties wired but NOT marked dirty. +// Used by the registry for decoding existing elements from BSON. +// When a storage alias exists, init uses the STORAGE name (what Mendix uses in BSON). +func initXmlSchemaEntry() *XmlSchemaEntry { + o := &XmlSchemaEntry{} + o.SetTypeName("XmlSchemas$XmlSchemaEntry") + o.targetNamespace = property.NewPrimitive[string]("TargetNamespace", property.DecodeString) + o.targetNamespace.Bind(&o.Base, 0) + o.location = property.NewPrimitive[string]("Location", property.DecodeString) + o.location.Bind(&o.Base, 1) + o.contents = property.NewPrimitive[string]("Contents", property.DecodeString) + o.contents.Bind(&o.Base, 2) + o.localizedLocationFormat = property.NewPrimitive[string]("LocalizedLocationFormat", property.DecodeString) + o.localizedLocationFormat.Bind(&o.Base, 3) + o.localizedContentsFormat = property.NewPrimitive[string]("LocalizedContentsFormat", property.DecodeString) + o.localizedContentsFormat.Bind(&o.Base, 4) + o.SetProperties([]element.Property{o.targetNamespace, o.location, o.contents, o.localizedLocationFormat, o.localizedContentsFormat}) + return o +} + +// NewXmlSchemaEntry creates a new XmlSchemaEntry for user code. Marked dirty (bit 63 = new element). +func NewXmlSchemaEntry() *XmlSchemaEntry { + o := initXmlSchemaEntry() + // TODO: applyDefaults(o) — populate mandatory fields from reflection-data + // See docs/superpowers/specs/2026-04-22-modelsdk-tech-debt-design.md Fix 4 + o.MarkDirty(63) + return o +} + +func init() { + codec.DefaultRegistry.Register("XmlSchemas$XmlElement", func() element.Element { + o := initXmlElement() + o.SetTypeName("XmlSchemas$XmlElement") + return o + }) + codec.DefaultRegistry.Register("XmlSchemas$XmlSchemaContents", func() element.Element { + return initXmlElement() + }) + codec.DefaultRegistry.Register("XmlSchemas$XmlSchema", func() element.Element { + return initXmlSchema() + }) + codec.DefaultRegistry.Register("XmlSchemas$XmlSchemaEntry", func() element.Element { + return initXmlSchemaEntry() + }) +} diff --git a/modelsdk/gen/xmlschemas/version.go b/modelsdk/gen/xmlschemas/version.go new file mode 100644 index 00000000..70782fd4 --- /dev/null +++ b/modelsdk/gen/xmlschemas/version.go @@ -0,0 +1,10 @@ +// Code generated by mxcli codegen; DO NOT EDIT. +// To modify: edit internal/codegen/supplements.json or internal/codegen/emitter/templates.go, +// then run: go run ./cmd/modelsdk-codegen + +package xmlschemas + +import "github.com/mendixlabs/mxcli/modelsdk/version" + +// VersionInfos maps structure-type names to their TypeVersionInfo. +var VersionInfos = map[string]version.TypeVersionInfo{} diff --git a/modelsdk/integration_test.go b/modelsdk/integration_test.go new file mode 100644 index 00000000..941628ed --- /dev/null +++ b/modelsdk/integration_test.go @@ -0,0 +1,400 @@ +package modelsdk_test + +import ( + "bytes" + "io" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/mendixlabs/mxcli/modelsdk" + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/gen/domainmodels" + "go.mongodb.org/mongo-driver/bson" + + _ "github.com/mendixlabs/mxcli/modelsdk/gen/domainmodels" +) + +// findTestMPR searches well-known locations for a test .mpr file. +func findTestMPR(t *testing.T) string { + t.Helper() + + patterns := []string{ + "mdl-examples/doctype-tests/app.mpr", + "reference/test-projects/*/app.mpr", + "mx-test-projects/*/app.mpr", + "mx-test-projects/*/*.mpr", + } + // All patterns are relative to the repo root. The test binary runs in the + // package directory (modelsdk/), so we go one level up. + root := filepath.Join("..", "") + for _, p := range patterns { + matches, _ := filepath.Glob(filepath.Join(root, p)) + if len(matches) > 0 { + return matches[0] + } + } + return "" +} + +// extractTypeName pulls the $Type string from raw BSON without the full Decoder. +func extractTypeName(raw bson.Raw) string { + val, err := raw.LookupErr("$Type") + if err != nil { + return "" + } + s, _ := val.StringValueOK() + return s +} + +func TestRoundtrip(t *testing.T) { + mprPath := findTestMPR(t) + if mprPath == "" { + t.Skip("no test MPR found — skipping integration test") + } + t.Logf("using MPR: %s", mprPath) + + store, err := codec.Open(mprPath) + if err != nil { + t.Fatalf("codec.Open: %v", err) + } + defer store.Close() + + units := store.ListUnits() + if len(units) == 0 { + t.Fatal("ListUnits returned 0 units") + } + t.Logf("total units: %d", len(units)) + + // ── Find and decode a DomainModel unit ────────────────────────────── + var dmRaw bson.Raw + var dmID string + + // Pick the largest DomainModel unit — it's most likely to have entities. + var bestSize int + for _, u := range units { + raw, err := store.LoadUnit(u.ID) + if err != nil { + continue + } + if extractTypeName(raw) == "DomainModels$DomainModel" { + if len(raw) > bestSize { + dmRaw = raw + dmID = string(u.ID) + bestSize = len(raw) + } + } + } + if dmRaw == nil { + t.Skip("no DomainModels$DomainModel unit found in MPR — skipping") + } + t.Logf("found DomainModel unit: %s (%d bytes)", dmID, len(dmRaw)) + + t.Run("DecodeDomainModel", func(t *testing.T) { + dec := codec.NewDecoder(codec.DefaultRegistry) + elem, err := dec.Decode(dmRaw) + if err != nil { + t.Fatalf("Decode: %v", err) + } + if elem.TypeName() != "DomainModels$DomainModel" { + t.Errorf("TypeName = %q, want %q", elem.TypeName(), "DomainModels$DomainModel") + } + if elem.ID() == "" { + t.Error("ID() is empty") + } + t.Logf("decoded element: type=%s id=%s", elem.TypeName(), elem.ID()) + + // Verify it decoded as the concrete DomainModel type, not a bare Base. + dm, ok := elem.(*domainmodels.DomainModel) + if !ok { + t.Fatalf("decoded element is %T, want *domainmodels.DomainModel", elem) + } + + // Properties slice should be populated by the factory. + if len(dm.Properties()) == 0 { + t.Error("Properties() is empty — factory did not wire properties") + } + t.Logf(" properties: %d", len(dm.Properties())) + }) + + t.Run("EncodeRoundtrip", func(t *testing.T) { + dec := codec.NewDecoder(codec.DefaultRegistry) + elem, err := dec.Decode(dmRaw) + if err != nil { + t.Fatalf("Decode: %v", err) + } + + enc := &codec.Encoder{} + encoded, err := enc.Encode(elem) + if err != nil { + t.Fatalf("Encode: %v", err) + } + + if len(encoded) != len(dmRaw) { + t.Errorf("encoded length %d != original length %d", len(encoded), len(dmRaw)) + } + if !bytes.Equal(encoded, []byte(dmRaw)) { + t.Error("encoded bytes differ from original — passthrough failed") + } + t.Logf("roundtrip OK: %d bytes", len(encoded)) + }) + + t.Run("DecodeEntities", func(t *testing.T) { + // Look for an Entities array inside the raw DomainModel BSON. + entitiesVal, err := dmRaw.LookupErr("Entities") + if err != nil { + t.Skip("no Entities array in DomainModel BSON — skipping entity decode test") + } + + arr, ok := entitiesVal.ArrayOK() + if !ok { + t.Skip("Entities field is not an array — skipping") + } + + elems, err := arr.Elements() + if err != nil || len(elems) == 0 { + t.Skip("Entities array is empty — skipping") + } + + t.Logf("found %d entity elements in DomainModel", len(elems)) + + dec := codec.NewDecoder(codec.DefaultRegistry) + decoded := 0 + for i, el := range elems { + doc, ok := el.Value().DocumentOK() + if !ok { + continue // skip non-document elements + } + typeName := extractTypeName(bson.Raw(doc)) + if typeName == "" { + continue + } + + entity, err := dec.Decode(bson.Raw(doc)) + if err != nil { + t.Errorf("entity[%d] Decode error: %v", i, err) + continue + } + + if !strings.HasPrefix(entity.TypeName(), "DomainModels$") { + t.Errorf("entity[%d] unexpected type: %s", i, entity.TypeName()) + continue + } + + // If it's an Entity, try reading the Name property. + if ent, ok := entity.(*domainmodels.Entity); ok { + name := ent.Name() + t.Logf(" entity[%d]: %s (name=%q)", i, entity.TypeName(), name) + } else { + t.Logf(" entity[%d]: %s (not *Entity, type=%T)", i, entity.TypeName(), entity) + } + decoded++ + } + + if decoded == 0 { + t.Error("no entities were decoded successfully") + } + t.Logf("successfully decoded %d/%d entities", decoded, len(elems)) + }) +} + +func TestModelAPI(t *testing.T) { + mprPath := findTestMPR(t) + if mprPath == "" { + t.Skip("no test MPR found") + } + + m, err := modelsdk.Open(mprPath) + if err != nil { + t.Fatalf("Open: %v", err) + } + defer m.Close() + + t.Run("Units", func(t *testing.T) { + units := m.Units() + if len(units) == 0 { + t.Fatal("no units") + } + t.Logf("total units: %d", len(units)) + }) + + t.Run("AllOfType", func(t *testing.T) { + dms := m.AllOfType("DomainModels$DomainModel") + if len(dms) == 0 { + t.Skip("no DomainModel units") + } + t.Logf("found %d DomainModel units", len(dms)) + + for _, dm := range dms { + if dm.TypeName() != "DomainModels$DomainModel" { + t.Errorf("unexpected type: %s", dm.TypeName()) + } + if _, ok := dm.(*domainmodels.DomainModel); !ok { + t.Errorf("expected *domainmodels.DomainModel, got %T", dm) + } + } + }) + + t.Run("LoadUnit", func(t *testing.T) { + units := m.Units() + if len(units) == 0 { + t.Skip("no units") + } + elem, err := m.LoadUnit(units[0].ID) + if err != nil { + t.Fatalf("LoadUnit: %v", err) + } + if elem.TypeName() == "" { + t.Error("TypeName empty") + } + t.Logf("loaded: %s", elem.TypeName()) + + // Load again — should be cached. + elem2, _ := m.LoadUnit(units[0].ID) + if elem != elem2 { + t.Error("expected cached element, got different pointer") + } + }) + + t.Run("EncodeModified", func(t *testing.T) { + dms := m.AllOfType("DomainModels$DomainModel") + if len(dms) == 0 { + t.Skip("no DomainModel units") + } + dm := dms[0].(*domainmodels.DomainModel) + original := dm.Documentation() + + dm.SetDocumentation("test-modified") + dm.MarkDirty(0) + + out, err := m.Encode(dm) + if err != nil { + t.Fatalf("Encode: %v", err) + } + + // Verify the encoded output has the modified value. + var doc bson.D + if err := bson.Unmarshal(out, &doc); err != nil { + t.Fatalf("Unmarshal: %v", err) + } + for _, e := range doc { + if e.Key == "documentation" { + if e.Value != "test-modified" { + t.Errorf("documentation = %v, want 'test-modified'", e.Value) + } + } + } + + // Restore original. + dm.SetDocumentation(original) + t.Logf("encode of modified element OK (%d bytes)", len(out)) + }) +} + +func TestWriteRoundtrip(t *testing.T) { + mprPath := findTestMPR(t) + if mprPath == "" { + t.Skip("no test MPR found") + } + + // Copy MPR to temp dir so we don't modify the original. + tmpDir := t.TempDir() + tmpMPR := filepath.Join(tmpDir, "test.mpr") + copyFile(t, mprPath, tmpMPR) + + // Also copy mprcontents/ if it exists (v2 format). + srcDir := filepath.Dir(mprPath) + srcContents := filepath.Join(srcDir, "mprcontents") + if info, err := os.Stat(srcContents); err == nil && info.IsDir() { + dstContents := filepath.Join(tmpDir, "mprcontents") + copyDir(t, srcContents, dstContents) + } + + // Open for writing, modify, flush, close. + m, err := modelsdk.OpenForWriting(tmpMPR) + if err != nil { + t.Fatalf("OpenForWriting: %v", err) + } + + dms := m.AllOfType("DomainModels$DomainModel") + if len(dms) == 0 { + m.Close() + t.Skip("no DomainModel units") + } + + dm := dms[0].(*domainmodels.DomainModel) + dm.SetDocumentation("modelsdk-write-test") + dm.MarkDirty(0) + + if _, err := m.Flush(); err != nil { + m.Close() + t.Fatalf("Flush: %v", err) + } + m.Close() + + // Reopen and verify the change persisted. + m2, err := modelsdk.Open(tmpMPR) + if err != nil { + t.Fatalf("reopen: %v", err) + } + defer m2.Close() + + dms2 := m2.AllOfType("DomainModels$DomainModel") + if len(dms2) == 0 { + t.Fatal("no DomainModel after reopen") + } + dm2 := dms2[0].(*domainmodels.DomainModel) + if dm2.Documentation() != "modelsdk-write-test" { + t.Errorf("after reopen, Documentation = %q, want 'modelsdk-write-test'", dm2.Documentation()) + } + t.Logf("write roundtrip OK: Documentation persisted as %q", dm2.Documentation()) +} + +func TestNewEntityFactory(t *testing.T) { + entity := domainmodels.NewEntity() + if entity == nil { + t.Fatal("NewEntity returned nil") + } + entity.SetName("TestCustomer") + if entity.Name() != "TestCustomer" { + t.Errorf("Name = %q", entity.Name()) + } + if entity.TypeName() == "" { + t.Error("TypeName empty") + } + t.Logf("NewEntity: type=%s name=%s props=%d", entity.TypeName(), entity.Name(), len(entity.Properties())) +} + +func copyFile(t *testing.T, src, dst string) { + t.Helper() + in, err := os.Open(src) + if err != nil { + t.Fatal(err) + } + defer in.Close() + out, err := os.Create(dst) + if err != nil { + t.Fatal(err) + } + defer out.Close() + if _, err := io.Copy(out, in); err != nil { + t.Fatal(err) + } +} + +func copyDir(t *testing.T, src, dst string) { + t.Helper() + filepath.Walk(src, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + rel, _ := filepath.Rel(src, path) + target := filepath.Join(dst, rel) + if info.IsDir() { + return os.MkdirAll(target, 0755) + } + copyFile(t, path, target) + return nil + }) +} diff --git a/modelsdk/meta/system_module.go b/modelsdk/meta/system_module.go new file mode 100644 index 00000000..208fb23e --- /dev/null +++ b/modelsdk/meta/system_module.go @@ -0,0 +1,496 @@ +// SPDX-License-Identifier: Apache-2.0 + +package meta + +// System module constants — deterministic IDs for the virtual System module. +const ( + SystemModuleID = "00000000-0000-0000-0000-000000000001" + SystemDomainModelID = "00000000-0000-0000-0000-000000000002" +) + +// SystemAttrDef defines an attribute in a System entity. +type SystemAttrDef struct { + Name string + Type string // "String", "Integer", "Decimal", "Boolean", "DateTime", "Enumeration", "Long", "Binary", "HashedString", "AutoNumber" + Length int // for String type + EnumQN string // for Enumeration type, qualified name +} + +// SystemAssocDef defines an association between System entities. +type SystemAssocDef struct { + Name string + Parent string // parent entity name (without module prefix) + Child string // child entity name (without module prefix) + Type string // "Reference" or "ReferenceSet" + Owner string // "Default" or "Both" +} + +// SystemEntityDef defines a System entity with name, persistability, and attributes. +type SystemEntityDef struct { + Name string + Persistable bool + Generalization string // e.g. "System.FileDocument", "System.Error" + Attributes []SystemAttrDef +} + +// SystemEntities lists all entities in the System module. +// Extracted from Mendix Studio Pro 11.6.4 via DummySystem module. +var SystemEntities = []SystemEntityDef{ + {Name: "UserRole", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "ModelGUID", Type: "String"}, + {Name: "Name", Type: "String"}, + {Name: "Description", Type: "String"}, + }}, + {Name: "User", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Name", Type: "String"}, + {Name: "Password", Type: "HashedString"}, + {Name: "LastLogin", Type: "DateTime"}, + {Name: "Blocked", Type: "Boolean"}, + {Name: "BlockedSince", Type: "DateTime"}, + {Name: "Active", Type: "Boolean"}, + {Name: "FailedLogins", Type: "Integer"}, + {Name: "WebServiceUser", Type: "Boolean"}, + {Name: "IsAnonymous", Type: "Boolean"}, + }}, + {Name: "FileDocument", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "FileID", Type: "AutoNumber"}, + {Name: "Name", Type: "String"}, + {Name: "DeleteAfterDownload", Type: "Boolean"}, + {Name: "Contents", Type: "Binary"}, + {Name: "HasContents", Type: "Boolean"}, + {Name: "Size", Type: "Long"}, + }}, + {Name: "Image", Persistable: true, Generalization: "System.FileDocument", Attributes: []SystemAttrDef{ + {Name: "PublicThumbnailPath", Type: "String"}, + {Name: "EnableCaching", Type: "Boolean"}, + }}, + {Name: "XASInstance", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "XASId", Type: "String"}, + {Name: "LastUpdate", Type: "DateTime"}, + {Name: "AllowedNumberOfConcurrentUsers", Type: "Integer"}, + {Name: "PartnerName", Type: "String"}, + {Name: "CustomerName", Type: "String"}, + }}, + {Name: "Session", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "SessionId", Type: "String"}, + {Name: "CSRFToken", Type: "String"}, + {Name: "LastActive", Type: "DateTime"}, + }}, + {Name: "ScheduledEventInformation", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Name", Type: "String"}, + {Name: "Description", Type: "String"}, + {Name: "StartTime", Type: "DateTime"}, + {Name: "EndTime", Type: "DateTime"}, + {Name: "Status", Type: "Enumeration", EnumQN: "System.EventStatus"}, + }}, + {Name: "Language", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Code", Type: "String"}, + {Name: "Description", Type: "String"}, + }}, + {Name: "TimeZone", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Code", Type: "String"}, + {Name: "Description", Type: "String"}, + {Name: "RawOffset", Type: "Integer"}, + }}, + {Name: "Error", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "ErrorType", Type: "String"}, + {Name: "Message", Type: "String"}, + {Name: "Stacktrace", Type: "String"}, + }}, + {Name: "SoapFault", Persistable: true, Generalization: "System.Error", Attributes: []SystemAttrDef{ + {Name: "Code", Type: "String"}, + {Name: "Reason", Type: "String"}, + {Name: "Node", Type: "String"}, + {Name: "Role", Type: "String"}, + {Name: "Detail", Type: "String"}, + }}, + {Name: "TokenInformation", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Token", Type: "HashedString"}, + {Name: "ExpiryDate", Type: "DateTime"}, + {Name: "UserAgent", Type: "String"}, + }}, + {Name: "HttpMessage", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "HttpVersion", Type: "String"}, + {Name: "Content", Type: "String"}, + }}, + {Name: "HttpHeader", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "Key", Type: "String"}, + {Name: "Value", Type: "String"}, + }}, + {Name: "UserReportInfo", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "UserType", Type: "Enumeration", EnumQN: "System.UserType"}, + {Name: "Hash", Type: "String"}, + }}, + {Name: "HttpRequest", Persistable: true, Generalization: "System.HttpMessage", Attributes: []SystemAttrDef{ + {Name: "Uri", Type: "String"}, + }}, + {Name: "HttpResponse", Persistable: true, Generalization: "System.HttpMessage", Attributes: []SystemAttrDef{ + {Name: "StatusCode", Type: "Integer"}, + {Name: "ReasonPhrase", Type: "String"}, + }}, + {Name: "Paging", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "PageNumber", Type: "Long"}, + {Name: "IsSortable", Type: "Boolean"}, + {Name: "SortAttribute", Type: "String"}, + {Name: "SortAscending", Type: "Boolean"}, + {Name: "HasMoreData", Type: "Boolean"}, + }}, + {Name: "SynchronizationError", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Reason", Type: "String"}, + {Name: "ObjectId", Type: "String"}, + {Name: "ObjectType", Type: "String"}, + {Name: "ObjectContent", Type: "String"}, + }}, + {Name: "SynchronizationErrorFile", Persistable: true, Generalization: "System.FileDocument"}, + {Name: "ProcessedQueueTask", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Sequence", Type: "Long"}, + {Name: "Status", Type: "Enumeration", EnumQN: "System.QueueTaskStatus"}, + {Name: "QueueId", Type: "String"}, + {Name: "QueueName", Type: "String"}, + {Name: "ContextType", Type: "Enumeration", EnumQN: "System.ContextType"}, + {Name: "ContextData", Type: "String"}, + {Name: "MicroflowName", Type: "String"}, + {Name: "UserActionName", Type: "String"}, + {Name: "Arguments", Type: "String"}, + {Name: "XASId", Type: "String"}, + {Name: "ThreadId", Type: "Long"}, + {Name: "Created", Type: "DateTime"}, + {Name: "StartAt", Type: "DateTime"}, + {Name: "Started", Type: "DateTime"}, + {Name: "Finished", Type: "DateTime"}, + {Name: "Duration", Type: "Long"}, + {Name: "Retried", Type: "Long"}, + {Name: "ErrorMessage", Type: "String"}, + {Name: "ScheduledEventName", Type: "String"}, + }}, + {Name: "QueuedTask", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Sequence", Type: "AutoNumber"}, + {Name: "Status", Type: "Enumeration", EnumQN: "System.QueueTaskStatus"}, + {Name: "QueueId", Type: "String"}, + {Name: "QueueName", Type: "String"}, + {Name: "ContextType", Type: "Enumeration", EnumQN: "System.ContextType"}, + {Name: "ContextData", Type: "String"}, + {Name: "MicroflowName", Type: "String"}, + {Name: "UserActionName", Type: "String"}, + {Name: "Arguments", Type: "String"}, + {Name: "XASId", Type: "String"}, + {Name: "ThreadId", Type: "Long"}, + {Name: "Created", Type: "DateTime"}, + {Name: "StartAt", Type: "DateTime"}, + {Name: "Started", Type: "DateTime"}, + {Name: "Retried", Type: "Long"}, + {Name: "Retry", Type: "String"}, + {Name: "ScheduledEventName", Type: "String"}, + }}, + {Name: "WorkflowDefinition", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Name", Type: "String"}, + {Name: "Title", Type: "String"}, + {Name: "IsObsolete", Type: "Boolean"}, + {Name: "IsLocked", Type: "Boolean"}, + }}, + {Name: "WorkflowUserTaskDefinition", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Name", Type: "String"}, + {Name: "IsObsolete", Type: "Boolean"}, + }}, + {Name: "Workflow", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Name", Type: "String"}, + {Name: "Description", Type: "String"}, + {Name: "StartTime", Type: "DateTime"}, + {Name: "EndTime", Type: "DateTime"}, + {Name: "DueDate", Type: "DateTime"}, + {Name: "CanBeRestarted", Type: "Boolean"}, + {Name: "CanBeContinued", Type: "Boolean"}, + {Name: "CanApplyJumpTo", Type: "Boolean"}, + {Name: "State", Type: "Enumeration", EnumQN: "System.WorkflowState"}, + {Name: "Reason", Type: "String"}, + }}, + {Name: "WorkflowUserTask", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Name", Type: "String"}, + {Name: "Description", Type: "String"}, + {Name: "StartTime", Type: "DateTime"}, + {Name: "DueDate", Type: "DateTime"}, + {Name: "EndTime", Type: "DateTime"}, + {Name: "Outcome", Type: "String"}, + {Name: "State", Type: "Enumeration", EnumQN: "System.WorkflowUserTaskState"}, + {Name: "CompletionType", Type: "Enumeration", EnumQN: "System.WorkflowUserTaskCompletionType"}, + }}, + {Name: "TaskQueueToken", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "QueueName", Type: "String"}, + {Name: "XASId", Type: "String"}, + {Name: "ValidUntil", Type: "DateTime"}, + }}, + {Name: "ODataResponse", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "Count", Type: "Long"}, + }}, + {Name: "WorkflowJumpToDetails", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "Error", Type: "String"}, + }}, + {Name: "WorkflowCurrentActivity", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "Action", Type: "Enumeration", EnumQN: "System.WorkflowCurrentActivityAction"}, + }}, + {Name: "WorkflowActivityDetails", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "ActivityId", Type: "String"}, + {Name: "ActivityCaption", Type: "String"}, + {Name: "ActivityType", Type: "Enumeration", EnumQN: "System.WorkflowActivityType"}, + {Name: "ExistsInCurrentVersion", Type: "Boolean"}, + }}, + {Name: "WorkflowUserTaskOutcome", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Outcome", Type: "String"}, + {Name: "Time", Type: "DateTime"}, + }}, + {Name: "WorkflowRecord", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "WorkflowKey", Type: "String"}, + {Name: "Name", Type: "String"}, + {Name: "Description", Type: "String"}, + {Name: "State", Type: "Enumeration", EnumQN: "System.WorkflowState"}, + {Name: "StartTime", Type: "DateTime"}, + {Name: "DueDate", Type: "DateTime"}, + {Name: "EndTime", Type: "DateTime"}, + {Name: "Reason", Type: "String"}, + }}, + {Name: "WorkflowActivityRecord", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "ModelGUID", Type: "String"}, + {Name: "ActivityKey", Type: "String"}, + {Name: "PreviousActivityKey", Type: "String"}, + {Name: "ActivityType", Type: "Enumeration", EnumQN: "System.WorkflowActivityType"}, + {Name: "Caption", Type: "String"}, + {Name: "State", Type: "Enumeration", EnumQN: "System.WorkflowActivityExecutionState"}, + {Name: "StartTime", Type: "DateTime"}, + {Name: "EndTime", Type: "DateTime"}, + {Name: "Outcome", Type: "String"}, + {Name: "MicroflowName", Type: "String"}, + {Name: "TaskName", Type: "String"}, + {Name: "TaskDescription", Type: "String"}, + {Name: "TaskDueDate", Type: "DateTime"}, + {Name: "TaskCompletionType", Type: "Enumeration", EnumQN: "System.WorkflowUserTaskCompletionType"}, + {Name: "TaskRequiredUsers", Type: "Integer"}, + {Name: "TaskKey", Type: "String"}, + {Name: "Reason", Type: "String"}, + }}, + {Name: "WorkflowEvent", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "EventTime", Type: "DateTime"}, + {Name: "EventType", Type: "Enumeration", EnumQN: "System.WorkflowEventType"}, + }}, + {Name: "ConsumedODataConfiguration", Persistable: false, Attributes: []SystemAttrDef{ + {Name: "ServiceUrl", Type: "String"}, + {Name: "ProxyConfiguration", Type: "Enumeration", EnumQN: "System.ProxyConfiguration"}, + {Name: "ProxyHost", Type: "String"}, + {Name: "ProxyPort", Type: "Integer"}, + {Name: "ProxyUsername", Type: "String"}, + {Name: "ProxyPassword", Type: "String"}, + }}, + {Name: "WorkflowEndedUserTask", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Name", Type: "String"}, + {Name: "Description", Type: "String"}, + {Name: "StartTime", Type: "DateTime"}, + {Name: "DueDate", Type: "DateTime"}, + {Name: "EndTime", Type: "DateTime"}, + {Name: "Outcome", Type: "String"}, + {Name: "State", Type: "Enumeration", EnumQN: "System.WorkflowUserTaskState"}, + {Name: "CompletionType", Type: "Enumeration", EnumQN: "System.WorkflowUserTaskCompletionType"}, + {Name: "UserTaskKey", Type: "String"}, + }}, + {Name: "WorkflowEndedUserTaskOutcome", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Outcome", Type: "String"}, + {Name: "Time", Type: "DateTime"}, + }}, + {Name: "WorkflowGroup", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Name", Type: "String"}, + {Name: "Description", Type: "String"}, + }}, + // --- Entities below extracted from MDP (Phase 3, 2026-04-24) --- + {Name: "WorkflowVersion", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "VersionHash", Type: "String"}, + {Name: "ModelJSON", Type: "String"}, + }}, + {Name: "WorkflowActivity", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "ModelGUID", Type: "String"}, + {Name: "ActivityGUID", Type: "String"}, + {Name: "Caption", Type: "String"}, + {Name: "DetailsJson", Type: "String"}, + {Name: "State", Type: "Enumeration", EnumQN: "System.WorkflowActivityState"}, + {Name: "StartTime", Type: "DateTime"}, + {Name: "EndTime", Type: "DateTime"}, + {Name: "ActionTime", Type: "DateTime"}, + {Name: "Reason", Type: "String"}, + {Name: "ActivityHash", Type: "String"}, + {Name: "IsDerivedActivity", Type: "Boolean"}, + {Name: "Outcome", Type: "String"}, + {Name: "OutcomeModelGUID", Type: "String"}, + }}, + {Name: "WorkflowActivityUserTaskOutcome", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Outcome", Type: "String"}, + {Name: "Time", Type: "DateTime"}, + }}, + {Name: "PrivateFileDocument", Persistable: true, Generalization: "System.FileDocument"}, + {Name: "Thumbnail", Persistable: true, Generalization: "System.Image"}, + {Name: "BackgroundJob", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "JobId", Type: "Long"}, + {Name: "StartTime", Type: "DateTime"}, + {Name: "EndTime", Type: "DateTime"}, + {Name: "Result", Type: "String"}, + {Name: "Successful", Type: "Boolean"}, + }}, + {Name: "AutoCommitEntry", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "SessionId", Type: "String"}, + {Name: "ObjectId", Type: "Long"}, + }}, + {Name: "UnreferencedFile", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "FileKey", Type: "String"}, + {Name: "State", Type: "Enumeration", EnumQN: "System.UnreferencedFileState"}, + {Name: "TransactionId", Type: "String"}, + }}, + {Name: "OfflineCreatedGuids", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "Guid", Type: "String"}, + }}, + {Name: "OfflineSynchronizationHistory", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "SyncId", Type: "String"}, + }}, + {Name: "ChangeHash", Persistable: true, Attributes: []SystemAttrDef{ + {Name: "ObjectId", Type: "Long"}, + {Name: "Attribute", Type: "String"}, + {Name: "Hash", Type: "String"}, + }}, +} + +// SystemAssociations lists all associations in the System module. +// Extracted from Mendix Studio Pro 11.6.4 via DummySystem module. +var SystemAssociations = []SystemAssocDef{ + {Name: "grantableRoles", Parent: "UserRole", Child: "UserRole", Type: "ReferenceSet", Owner: "Default"}, + {Name: "UserRoles", Parent: "User", Child: "UserRole", Type: "ReferenceSet", Owner: "Default"}, + {Name: "Session_User", Parent: "Session", Child: "User", Type: "Reference", Owner: "Default"}, + {Name: "User_Language", Parent: "User", Child: "Language", Type: "Reference", Owner: "Default"}, + {Name: "User_TimeZone", Parent: "User", Child: "TimeZone", Type: "Reference", Owner: "Default"}, + {Name: "TokenInformation_User", Parent: "TokenInformation", Child: "User", Type: "Reference", Owner: "Default"}, + {Name: "HttpHeaders", Parent: "HttpHeader", Child: "HttpMessage", Type: "Reference", Owner: "Default"}, + {Name: "UserReportInfo_User", Parent: "UserReportInfo", Child: "User", Type: "Reference", Owner: "Default"}, + {Name: "ScheduledEventInformation_XASInstance", Parent: "ScheduledEventInformation", Child: "XASInstance", Type: "Reference", Owner: "Default"}, + {Name: "SynchronizationErrorFile_SynchronizationError", Parent: "SynchronizationErrorFile", Child: "SynchronizationError", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowUserTaskDefinition_WorkflowDefinition", Parent: "WorkflowUserTaskDefinition", Child: "WorkflowDefinition", Type: "Reference", Owner: "Default"}, + {Name: "Workflow_WorkflowDefinition", Parent: "Workflow", Child: "WorkflowDefinition", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowUserTask_TargetUsers", Parent: "WorkflowUserTask", Child: "User", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowUserTask_Assignees", Parent: "WorkflowUserTask", Child: "User", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowUserTask_Workflow", Parent: "WorkflowUserTask", Child: "Workflow", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowUserTask_WorkflowUserTaskDefinition", Parent: "WorkflowUserTask", Child: "WorkflowUserTaskDefinition", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowJumpToDetails_Workflow", Parent: "WorkflowJumpToDetails", Child: "Workflow", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowJumpToDetails_CurrentActivities", Parent: "WorkflowJumpToDetails", Child: "WorkflowCurrentActivity", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowCurrentActivity_ActivityDetails", Parent: "WorkflowCurrentActivity", Child: "WorkflowActivityDetails", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowCurrentActivity_ApplicableTargets", Parent: "WorkflowCurrentActivity", Child: "WorkflowActivityDetails", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowCurrentActivity_JumpToTarget", Parent: "WorkflowCurrentActivity", Child: "WorkflowActivityDetails", Type: "Reference", Owner: "Default"}, + {Name: "Workflow_ParentWorkflow", Parent: "Workflow", Child: "Workflow", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowUserTaskOutcome_WorkflowUserTask", Parent: "WorkflowUserTaskOutcome", Child: "WorkflowUserTask", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowUserTaskOutcome_User", Parent: "WorkflowUserTaskOutcome", Child: "User", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowRecord_Workflow", Parent: "WorkflowRecord", Child: "Workflow", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowRecord_Owner", Parent: "WorkflowRecord", Child: "User", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowRecord_WorkflowDefinition", Parent: "WorkflowRecord", Child: "WorkflowDefinition", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivityRecord_PreviousActivity", Parent: "WorkflowActivityRecord", Child: "WorkflowActivityRecord", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivityRecord_Actor", Parent: "WorkflowActivityRecord", Child: "User", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivityRecord_SubWorkflow", Parent: "WorkflowActivityRecord", Child: "WorkflowRecord", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivityRecord_UserTask", Parent: "WorkflowActivityRecord", Child: "WorkflowUserTask", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivityRecord_WorkflowUserTaskDefinition", Parent: "WorkflowActivityRecord", Child: "WorkflowUserTaskDefinition", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowEvent_Initiator", Parent: "WorkflowEvent", Child: "User", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivityRecord_TaskTargetedUsers", Parent: "WorkflowActivityRecord", Child: "User", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowActivityRecord_TaskAssignedUsers", Parent: "WorkflowActivityRecord", Child: "User", Type: "ReferenceSet", Owner: "Default"}, + {Name: "HttpHeader_ConsumedODataConfiguration", Parent: "HttpHeader", Child: "ConsumedODataConfiguration", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowEndedUserTask_Assignees", Parent: "WorkflowEndedUserTask", Child: "User", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowEndedUserTask_TargetUsers", Parent: "WorkflowEndedUserTask", Child: "User", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowEndedUserTask_WorkflowUserTaskDefinition", Parent: "WorkflowEndedUserTask", Child: "WorkflowUserTaskDefinition", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowEndedUserTask_Workflow", Parent: "WorkflowEndedUserTask", Child: "Workflow", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowEndedUserTaskOutcome_User", Parent: "WorkflowEndedUserTaskOutcome", Child: "User", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowEndedUserTaskOutcome_WorkflowEndedUserTask", Parent: "WorkflowEndedUserTaskOutcome", Child: "WorkflowEndedUserTask", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowGroup_User", Parent: "WorkflowGroup", Child: "User", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowUserTask_TargetGroups", Parent: "WorkflowUserTask", Child: "WorkflowGroup", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowEndedUserTask_TargetGroups", Parent: "WorkflowEndedUserTask", Child: "WorkflowGroup", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowActivityRecord_TaskTargetedGroups", Parent: "WorkflowActivityRecord", Child: "WorkflowGroup", Type: "ReferenceSet", Owner: "Default"}, + // --- Associations below extracted from MDP (Phase 3, 2026-04-24) --- + {Name: "WorkflowVersion_WorkflowDefinition", Parent: "WorkflowVersion", Child: "WorkflowDefinition", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowVersion_WorkflowUserTaskDefinition", Parent: "WorkflowVersion", Child: "WorkflowUserTaskDefinition", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowVersion_PreviousVersion", Parent: "WorkflowVersion", Child: "WorkflowVersion", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowDefinition_CurrentWorkflowVersion", Parent: "WorkflowDefinition", Child: "WorkflowVersion", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivity_Workflow", Parent: "WorkflowActivity", Child: "Workflow", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivity_WorkflowUserTask", Parent: "WorkflowActivity", Child: "WorkflowUserTask", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivity_PreviousActivity", Parent: "WorkflowActivity", Child: "WorkflowActivity", Type: "ReferenceSet", Owner: "Default"}, + {Name: "Workflow_CurrentActivity", Parent: "Workflow", Child: "WorkflowActivity", Type: "ReferenceSet", Owner: "Default"}, + {Name: "WorkflowActivity_WorkflowVersion", Parent: "WorkflowActivity", Child: "WorkflowVersion", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivity_Actor", Parent: "WorkflowActivity", Child: "User", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivity_SubWorkflow", Parent: "WorkflowActivity", Child: "Workflow", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivityUserTaskOutcome_WorkflowActivity", Parent: "WorkflowActivityUserTaskOutcome", Child: "WorkflowActivity", Type: "Reference", Owner: "Default"}, + {Name: "WorkflowActivityUserTaskOutcome_User", Parent: "WorkflowActivityUserTaskOutcome", Child: "User", Type: "Reference", Owner: "Default"}, + {Name: "Thumbnail_Image", Parent: "Thumbnail", Child: "Image", Type: "Reference", Owner: "Both"}, + {Name: "BackgroundJob_Session", Parent: "BackgroundJob", Child: "Session", Type: "Reference", Owner: "Default"}, + {Name: "BackgroundJob_XASInstance", Parent: "BackgroundJob", Child: "XASInstance", Type: "Reference", Owner: "Default"}, + {Name: "UnreferencedFile_XASInstance", Parent: "UnreferencedFile", Child: "XASInstance", Type: "Reference", Owner: "Default"}, + {Name: "ChangeHash_Session", Parent: "ChangeHash", Child: "Session", Type: "Reference", Owner: "Default"}, +} + +// SystemEnumDef defines an enumeration in the System module. +type SystemEnumDef struct { + Name string // qualified name, e.g. "System.EventStatus" + Values []string // enumeration value names +} + +// SystemEnumerations lists all enumerations in the System module. +// Extracted from Mendix mxbuild 11.6.4 MDP output. +var SystemEnumerations = []SystemEnumDef{ + {Name: "System.ContextType", Values: []string{ + "System", "User", "Anonymous", "ScheduledEvent", + }}, + {Name: "System.EventStatus", Values: []string{ + "Running", "Completed", "Error", "Stopped", + }}, + {Name: "System.DeviceType", Values: []string{ + "Phone", "Tablet", "Desktop", + }}, + {Name: "System.UserType", Values: []string{ + "Internal", "External", + }}, + {Name: "System.ProxyConfiguration", Values: []string{ + "UseAppSettings", "Override", "NoProxy", + }}, + {Name: "System.QueueTaskStatus", Values: []string{ + "Idle", "Running", "Completed", "Failed", "Retrying", "Aborted", "Incompatible", + }}, + {Name: "System.WorkflowActivityState", Values: []string{ + "Started", "Suspended", "Finished", "Replaced", "Aborted", "Failed", + }}, + {Name: "System.UnreferencedFileState", Values: []string{ + "New", "Obsolete", "Deleted", + }}, + {Name: "System.WorkflowActivityExecutionState", Values: []string{ + "Created", "InProgress", "Completed", "Paused", "Aborted", "Failed", + }}, + {Name: "System.WorkflowState", Values: []string{ + "InProgress", "Paused", "Completed", "Aborted", "Incompatible", "Failed", + }}, + {Name: "System.WorkflowUserTaskState", Values: []string{ + "Created", "InProgress", "Completed", "Paused", "Aborted", "Failed", + }}, + {Name: "System.WorkflowActivityType", Values: []string{ + "Start", "End", "ExclusiveSplit", "ParallelSplit", + "ParallelSplitBranchStopper", "ParallelSplitMerge", + "UserTask", "CallMicroflow", "CallWorkflow", "JumpTo", + "MultiInputUserTask", "WaitForNotification", "WaitForTimer", + "EndOfBoundaryEventPath", "NonInterruptingTimerEvent", "InterruptingTimerEvent", + }}, + {Name: "System.WorkflowCurrentActivityAction", Values: []string{ + "DoNothing", "JumpTo", + }}, + {Name: "System.WorkflowUserTaskCompletionType", Values: []string{ + "Single", "Veto", "Consensus", "Majority", "Threshold", "Microflow", + }}, + {Name: "System.WorkflowEventType", Values: []string{ + "WorkflowCompleted", "WorkflowInitiated", "WorkflowRestarted", + "WorkflowFailed", "WorkflowAborted", "WorkflowPaused", + "WorkflowUnpaused", "WorkflowRetried", "WorkflowUpdated", + "WorkflowUpgraded", "WorkflowConflicted", "WorkflowResolved", + "WorkflowJumpToOptionApplied", + "StartEventExecuted", "EndEventExecuted", "DecisionExecuted", + "JumpExecuted", "ParallelSplitExecuted", "ParallelMergeExecuted", + "CallWorkflowStarted", "CallWorkflowEnded", + "CallMicroflowStarted", "CallMicroflowEnded", + "WaitForNotificationStarted", "WaitForNotificationEnded", + "WaitForTimerStarted", "WaitForTimerEnded", + "UserTaskStarted", "MultiUserTaskOutcomeSelected", "UserTaskEnded", + "NonInterruptingTimerEventExecuted", "InterruptingTimerEventExecuted", + }}, +} diff --git a/modelsdk/model.go b/modelsdk/model.go new file mode 100644 index 00000000..caa16b5f --- /dev/null +++ b/modelsdk/model.go @@ -0,0 +1,376 @@ +// Package modelsdk provides typed, lazy-decoded access to Mendix project files (.mpr). +// +// Usage: +// +// import _ "github.com/mendixlabs/mxcli/modelsdk/gen/domainmodels" +// +// m, err := modelsdk.Open("app.mpr") +// defer m.Close() +// for _, dm := range m.AllOfType("DomainModels$DomainModel") { ... } +// +// // Read-write: +// m, err := modelsdk.OpenForWriting("app.mpr") +// entity.SetName("NewName") +// entity.MarkDirty(0) +// m.Flush() +package modelsdk + +import ( + "fmt" + "os" + "path/filepath" + "strings" + + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "go.mongodb.org/mongo-driver/bson" +) + +// Model provides high-level access to a Mendix project. +type Model struct { + store *codec.Store + decoder *codec.Decoder + encoder *codec.Encoder + uc *UnitCache + units []codec.UnitInfo + modules *ModuleResolver +} + +// Open opens an MPR file for reading. +func Open(path string) (*Model, error) { + store, err := codec.Open(path) + if err != nil { + return nil, err + } + return newModel(store), nil +} + +// OpenForWriting opens an MPR file for reading and writing. +func OpenForWriting(path string) (*Model, error) { + store, err := codec.OpenForWriting(path) + if err != nil { + return nil, err + } + return newModel(store), nil +} + +func newModel(store *codec.Store) *Model { + m := &Model{ + store: store, + decoder: codec.NewDecoder(codec.DefaultRegistry), + encoder: &codec.Encoder{}, + uc: newUnitCache(), + } + m.units = store.ListUnits() + m.uc.RebuildNameIndex(m.units) + m.modules = newModuleResolver(store, func() []codec.UnitInfo { return m.units }) + return m +} + +// Close closes the underlying store. +func (m *Model) Close() error { + return m.store.Close() +} + +// IsWritable returns true if the model was opened for writing. +func (m *Model) IsWritable() bool { + return m.store.IsWritable() +} + +// Units returns metadata for all document units in the MPR. +func (m *Model) Units() []codec.UnitInfo { + return m.units +} + +// LoadUnit loads and decodes a single unit by ID. Results are cached. +// Safe for concurrent use. +func (m *Model) LoadUnit(id element.ID) (element.Element, error) { + if elem, ok := m.uc.Get(id); ok { + return elem, nil + } + + raw, err := m.store.LoadUnit(id) + if err != nil { + return nil, err + } + elem, err := m.decoder.Decode(raw) + if err != nil { + return nil, fmt.Errorf("decode unit %s: %w", id, err) + } + + m.uc.Put(id, elem) + return elem, nil +} + +// AllOfType loads and returns all units whose $Type matches the given type name. +// Uses UnitInfo.Type metadata to pre-filter, avoiding BSON I/O for non-matching units. +// Safe for concurrent use. +func (m *Model) AllOfType(typeName string) []element.Element { + var result []element.Element + currentTypeGen := m.uc.TypeGen(typeName) + + for _, u := range m.units { + // Fast path: skip units whose metadata type doesn't match. + if u.Type != "" && u.Type != typeName { + continue + } + + // Use cached element if available AND it was cached in the current + // per-type generation. This preserves in-memory mutations made by + // earlier statements in the same batch (e.g., CREATE ENTITY followed + // by CREATE ASSOCIATION) while forcing a re-decode only when units of + // this specific type have changed (InsertUnit/DeleteUnit bumps typeGen + // for the affected type only). + cached, cachedGen, hasCached := m.uc.GetWithGen(u.ID) + if hasCached && cachedGen >= currentTypeGen && u.Type != "" { + result = append(result, cached) + continue + } + + raw, err := m.store.LoadUnit(u.ID) + if err != nil { + continue + } + // Fallback: if metadata type was empty, check BSON $Type field. + if u.Type == "" { + if decodeTypeField(raw) != typeName { + continue + } + } + + // If cached in this generation (but type was empty so we had to verify), return cached version + if hasCached && cachedGen >= currentTypeGen { + result = append(result, cached) + continue + } + + elem, err := m.decoder.Decode(raw) + if err != nil { + continue + } + m.uc.PutWithGen(u.ID, elem, currentTypeGen) + result = append(result, elem) + } + return result +} + +// FindByQualifiedName searches for a unit of the given type whose +// "Name" property matches qualifiedName. Uses the name index for O(1) +// lookup, falling back to a linear scan if the index misses. +func (m *Model) FindByQualifiedName(typeName, qualifiedName string) (element.Element, error) { + // Fast path: index lookup. + if id, ok := m.uc.FindByName(typeName + ":" + qualifiedName); ok { + return m.LoadUnit(id) + } + + // Fallback: linear scan (covers units whose Type/Name metadata was empty). + for _, u := range m.units { + if u.Type != "" && u.Type != typeName { + continue + } + raw, err := m.store.LoadUnit(u.ID) + if err != nil { + continue + } + if u.Type == "" && decodeTypeField(raw) != typeName { + continue + } + name, _ := raw.LookupErr("Name") + if s, ok := name.StringValueOK(); ok && s == qualifiedName { + elem, err := m.decoder.Decode(raw) + if err != nil { + return nil, fmt.Errorf("decode unit %s: %w", u.ID, err) + } + m.uc.Put(u.ID, elem) + return elem, nil + } + } + return nil, fmt.Errorf("element %s with name %q not found", typeName, qualifiedName) +} + +// Encode serializes an element to BSON bytes. +func (m *Model) Encode(elem element.Element) ([]byte, error) { + return m.encoder.Encode(elem) +} + +// Flush encodes and saves all dirty cached units back to the MPR. +// Returns the number of units written and an error if the model is read-only. +func (m *Model) Flush() (int, error) { + if !m.store.IsWritable() { + return 0, fmt.Errorf("model is read-only — use OpenForWriting") + } + + dirtyElems := m.uc.DirtyUnits() + dirty := map[element.ID][]byte{} + for id, elem := range dirtyElems { + data, err := m.encoder.Encode(elem) + if err != nil { + return 0, fmt.Errorf("encode unit %s: %w", id, err) + } + dirty[id] = data + } + + if len(dirty) == 0 { + return 0, nil // nothing to flush + } + + return len(dirty), m.store.FlushUnits(dirty) +} + +// ModuleMap returns a mapping from module unit ID to module name. +func (m *Model) ModuleMap() map[element.ID]string { + return m.modules.ModuleMap() +} + +// ResolveModuleName finds the module name for a unit by walking the container hierarchy upward. +func (m *Model) ResolveModuleName(containerID element.ID) string { + return m.modules.ResolveModuleName(containerID) +} + +// GetProjectRootID returns the ID of the project root unit. +func (m *Model) GetProjectRootID() (string, error) { + return m.store.GetProjectRootID() +} + +// Store returns the underlying codec.Store for low-level unit access. +func (m *Model) Store() *codec.Store { return m.store } + +// PatchEncodedField sets a top-level field on already-encoded BSON bytes. +// Use this only when the SDK type's setter has a different type than the +// BSON storage format (e.g., SDK uses Part[element.Element] but BSON stores +// a plain string). This is a last-resort escape hatch. +func (m *Model) PatchEncodedField(data []byte, key string, value any) ([]byte, error) { + return codec.PatchBSONField(data, key, value) +} + +// PatchEncodedNestedField sets a field within a nested document in encoded BSON. +func (m *Model) PatchEncodedNestedField(data []byte, parentKey, childKey string, value any) ([]byte, error) { + return codec.PatchNestedBSONField(data, parentKey, childKey, value) +} + +// PatchEncodedVersionedArrayElements patches fields on elements of a versioned +// BSON array by index. patches maps element index (0-based, skipping the +// version marker) to a map of field-name -> value. +func (m *Model) PatchEncodedVersionedArrayElements(data []byte, arrayKey string, patches map[int]map[string]any) ([]byte, error) { + return codec.PatchVersionedArrayElements(data, arrayKey, patches) +} + +// ScanUnitStrings scans a unit's raw BSON for string values without +// decoding into SDK types. fn receives (fieldPath, value) for each +// string field. Return false to stop scanning. +// Used by search — avoids the cost of full SDK decode. +func (m *Model) ScanUnitStrings(id element.ID, fn func(fieldPath, value string) bool) { + raw, err := m.store.LoadUnit(id) + if err != nil { + return + } + codec.ScanBSONStrings(raw, fn) +} + +// InsertUnit creates a new document unit in the MPR. +func (m *Model) InsertUnit(id element.ID, containerID element.ID, containmentName, typeName string, data []byte) error { + if err := m.store.InsertUnit(string(id), string(containerID), containmentName, typeName, data); err != nil { + return err + } + + // Extract Name from BSON for the name index (single field decode, not full scan). + name := decodeBSONNameField(data) + + m.uc.BumpGen(typeName) + // Incremental update: append to units slice + add to name index. + m.units = append(m.units, codec.UnitInfo{ + ID: id, + ContainerID: containerID, + Type: typeName, + Name: name, + }) + m.uc.AddToNameIndex(typeName, name, id) + return nil +} + +// DeleteUnit removes a document unit from the MPR. +func (m *Model) DeleteUnit(id element.ID) error { + // Find the unit metadata before deleting (for incremental index update). + var deletedType, deletedName string + deletedType = m.uc.TypeNameOf(id) + for i, u := range m.units { + if u.ID == id { + if deletedType == "" { + deletedType = u.Type + } + deletedName = u.Name + // Remove from slice in-place. + m.units = append(m.units[:i], m.units[i+1:]...) + break + } + } + + if err := m.store.DeleteUnit(string(id)); err != nil { + return err + } + m.uc.Delete(id) + m.uc.BumpGen(deletedType) + m.uc.RemoveFromNameIndex(deletedType, deletedName) + return nil +} + +// DeleteModuleWithCleanup deletes a module, all its child units, and its themesource directory. +// Uses a single full-reload after all deletes (bulk operation, not incremental). +func (m *Model) DeleteModuleWithCleanup(moduleID element.ID, moduleName string) error { + if !m.store.IsWritable() { + return fmt.Errorf("model is read-only — use OpenForWriting") + } + + // Recursively delete child units in the store (bypasses Model cache). + if err := m.store.DeleteChildUnits(string(moduleID)); err != nil { + return fmt.Errorf("delete child units: %w", err) + } + + // Delete the module unit itself in the store. + if err := m.store.DeleteUnit(string(moduleID)); err != nil { + return fmt.Errorf("delete module unit: %w", err) + } + + // Bulk cleanup: clear cache entries for deleted units and do a single full reload. + m.uc.Delete(moduleID) + m.uc.BumpGen("") + + // Full reload is appropriate here — module deletion is rare and removes many units. + m.units = m.store.ListUnits() + m.uc.RebuildNameIndex(m.units) + m.modules.Invalidate() + + // Clean up themesource directory. + projectDir := filepath.Dir(m.store.Path()) + themesourceDir := filepath.Join(projectDir, "themesource", strings.ToLower(moduleName)) + if stat, err := os.Stat(themesourceDir); err == nil && stat.IsDir() { + os.RemoveAll(themesourceDir) + } + + return nil +} + +// InvalidateCache removes a cached element so it will be reloaded on next access. +func (m *Model) InvalidateCache(id element.ID) { + m.uc.Delete(id) +} + +func decodeTypeField(raw bson.Raw) string { + val, err := raw.LookupErr("$Type") + if err != nil { + return "" + } + s, _ := val.StringValueOK() + return s +} + +// decodeBSONNameField extracts the "Name" string from raw BSON data. +// Returns "" if the field is missing or not a string. +func decodeBSONNameField(data []byte) string { + val, err := bson.Raw(data).LookupErr("Name") + if err != nil { + return "" + } + s, _ := val.StringValueOK() + return s +} diff --git a/modelsdk/model_test.go b/modelsdk/model_test.go new file mode 100644 index 00000000..cbb60cb1 --- /dev/null +++ b/modelsdk/model_test.go @@ -0,0 +1,151 @@ +package modelsdk_test + +import ( + "crypto/rand" + "fmt" + "os" + "path/filepath" + "testing" + + "github.com/mendixlabs/mxcli/modelsdk" + "github.com/mendixlabs/mxcli/modelsdk/element" + + _ "github.com/mendixlabs/mxcli/modelsdk/gen/domainmodels" + _ "github.com/mendixlabs/mxcli/modelsdk/gen/enumerations" +) + +// copyMPRForWrite copies an MPR (and mprcontents/ for v2 format) to a temp +// directory and returns the path to the copy. +func copyMPRForWrite(t *testing.T, src string) string { + t.Helper() + tmpDir := t.TempDir() + dst := filepath.Join(tmpDir, filepath.Base(src)) + copyFile(t, src, dst) + + // Also copy mprcontents/ if it exists (v2 format). + srcDir := filepath.Dir(src) + srcContents := filepath.Join(srcDir, "mprcontents") + if info, err := os.Stat(srcContents); err == nil && info.IsDir() { + dstContents := filepath.Join(tmpDir, "mprcontents") + copyDir(t, srcContents, dstContents) + } + return dst +} + +// newUUID generates a random UUID string for test use. +func newUUID(t *testing.T) string { + t.Helper() + b := make([]byte, 16) + if _, err := rand.Read(b); err != nil { + t.Fatalf("rand.Read: %v", err) + } + return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", + b[0:4], b[4:6], b[6:8], b[8:10], b[10:16]) +} + +// TestFlushReturnsCount verifies that Flush() returns the number of units written. +func TestFlushReturnsCount(t *testing.T) { + mprPath := findTestMPR(t) + if mprPath == "" { + t.Skip("no test MPR found") + } + tmpMPR := copyMPRForWrite(t, mprPath) + m, err := modelsdk.OpenForWriting(tmpMPR) + if err != nil { + t.Fatalf("OpenForWriting: %v", err) + } + defer m.Close() + + n, err := m.Flush() + if err != nil { + t.Fatalf("Flush() error: %v", err) + } + if n != 0 { + t.Errorf("Flush() with no modifications returned n=%d, want 0", n) + } +} + +// TestAllOfTypePerTypeCacheIsolation verifies that inserting a unit of +// type A does not invalidate cached elements of type B. +func TestAllOfTypePerTypeCacheIsolation(t *testing.T) { + mprPath := findTestMPR(t) + if mprPath == "" { + t.Skip("no test MPR found") + } + tmpMPR := copyMPRForWrite(t, mprPath) + m, err := modelsdk.OpenForWriting(tmpMPR) + if err != nil { + t.Fatalf("OpenForWriting: %v", err) + } + defer m.Close() + + // Try a sequence of type names in order of likelihood to be present. + // We need at least one pre-existing unit of typeA to populate the cache. + // typeB is what we insert — it must be a different type than typeA. + type testCase struct { + typeA string // type to cache and verify pointer identity + typeB string // type to insert (must differ from typeA) + } + candidates := []testCase{ + {"Enumerations$Enumeration", "DomainModels$DomainModel"}, + {"DomainModels$DomainModel", "Microflows$Microflow"}, + {"Microflows$Microflow", "DomainModels$DomainModel"}, + {"Pages$Page", "DomainModels$DomainModel"}, + } + + var chosen *testCase + var elementsBefore []element.Element + for i := range candidates { + tc := &candidates[i] + elems := m.AllOfType(tc.typeA) + if len(elems) > 0 { + chosen = tc + elementsBefore = elems + break + } + } + if chosen == nil { + t.Skip("no suitable unit types found in test project") + } + + t.Logf("testing with typeA=%s (%d units), inserting typeB=%s", chosen.typeA, len(elementsBefore), chosen.typeB) + + // Find a valid container unit to use as parent for the new unit. + units := m.Units() + if len(units) == 0 { + t.Skip("no units in MPR") + } + containerID := units[0].ID + + // Insert a unit of typeB (different type from typeA). + // Use a minimal BSON document with just a $Type field. + dummyData := []byte{5, 0, 0, 0, 0} // minimal empty BSON document + newID := element.ID(newUUID(t)) + err = m.InsertUnit( + newID, + containerID, + "Documents", + chosen.typeB, + dummyData, + ) + if err != nil { + // InsertUnit failing is acceptable if the MPR writer rejects the data. + // Skip rather than fail — the test environment may not support arbitrary inserts. + t.Skipf("InsertUnit with dummy data returned error (ok for this test env): %v", err) + } + + // AllOfType for typeA should still return cached elements + // without re-decoding (same pointers). + elementsAfter := m.AllOfType(chosen.typeA) + if len(elementsAfter) != len(elementsBefore) { + t.Fatalf("element count changed: before=%d after=%d", len(elementsBefore), len(elementsAfter)) + } + + // Verify pointer identity — cached elements should be the same objects. + for i := range elementsBefore { + if elementsBefore[i] != elementsAfter[i] { + t.Errorf("element[%d] of type %s: got different pointer after inserting unrelated type %s (re-decoded when it shouldn't have)", i, chosen.typeA, chosen.typeB) + break + } + } +} diff --git a/modelsdk/module_resolver.go b/modelsdk/module_resolver.go new file mode 100644 index 00000000..cdb10a1e --- /dev/null +++ b/modelsdk/module_resolver.go @@ -0,0 +1,71 @@ +package modelsdk + +import ( + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" + "go.mongodb.org/mongo-driver/bson" +) + +// ModuleResolver caches and resolves module names from the unit hierarchy. +type ModuleResolver struct { + store *codec.Store + units func() []codec.UnitInfo // accessor to get current unit list + cache map[element.ID]string +} + +func newModuleResolver(store *codec.Store, units func() []codec.UnitInfo) *ModuleResolver { + return &ModuleResolver{store: store, units: units} +} + +// ModuleMap returns a mapping from module unit ID to module name. +func (r *ModuleResolver) ModuleMap() map[element.ID]string { + if r.cache != nil { + return r.cache + } + result := make(map[element.ID]string) + for _, u := range r.units() { + raw, err := r.store.LoadUnit(u.ID) + if err != nil { + continue + } + tn := decodeTypeField(raw) + if tn != "Projects$ModuleImpl" { + continue + } + name, err := bson.Raw(raw).LookupErr("Name") + if err != nil { + continue + } + if s, ok := name.StringValueOK(); ok { + result[u.ID] = s + } + } + r.cache = result + return result +} + +// ResolveModuleName finds the module name for a unit by walking the container hierarchy. +func (r *ModuleResolver) ResolveModuleName(containerID element.ID) string { + moduleMap := r.ModuleMap() + parentMap := make(map[element.ID]element.ID) + for _, u := range r.units() { + parentMap[u.ID] = u.ContainerID + } + current := containerID + for range 20 { + if name, ok := moduleMap[current]; ok { + return name + } + parent, ok := parentMap[current] + if !ok || parent == current { + break + } + current = parent + } + return "" +} + +// Invalidate clears the cached module map. +func (r *ModuleResolver) Invalidate() { + r.cache = nil +} diff --git a/modelsdk/mpr/parser.go b/modelsdk/mpr/parser.go new file mode 100644 index 00000000..2c0725e7 --- /dev/null +++ b/modelsdk/mpr/parser.go @@ -0,0 +1,253 @@ +// SPDX-License-Identifier: Apache-2.0 + +package mpr + +import ( + "encoding/base64" + "strings" + + "go.mongodb.org/mongo-driver/bson/primitive" +) + +// extractBsonID extracts an ID string from various BSON ID representations. +// Mendix stores IDs as Binary with Subtype/Data or as primitive.Binary. +func extractBsonID(v any) string { + if v == nil { + return "" + } + + switch val := v.(type) { + case string: + return val + case []byte: + return blobToUUID(val) + case primitive.Binary: + return blobToUUID(val.Data) + case map[string]any: + // Binary UUID stored as {Subtype: 0, Data: "base64..."} + if data, ok := val["Data"].(string); ok { + decoded, err := base64.StdEncoding.DecodeString(data) + if err == nil { + return blobToUUID(decoded) + } + } + // Also try $ID field + if id, ok := val["$ID"]; ok { + return extractBsonID(id) + } + } + + return "" +} + +// extractInt extracts an integer from various BSON number types. +func extractInt(v any) int { + if v == nil { + return 0 + } + switch val := v.(type) { + case int32: + return int(val) + case int64: + return int(val) + case int: + return val + case float64: + return int(val) + } + return 0 +} + +// extractString extracts a string from various BSON representations. +func extractString(v any) string { + if v == nil { + return "" + } + if s, ok := v.(string); ok { + return s + } + return "" +} + +// extractBool extracts a boolean from BSON, with default value. +func extractBool(v any, defaultVal bool) bool { + if v == nil { + return defaultVal + } + if b, ok := v.(bool); ok { + return b + } + return defaultVal +} + +// extractBsonArray extracts items from a Mendix BSON array. +// Mendix arrays start with a type indicator (2 or 3 for storageListType), followed by items. +func extractBsonArray(v any) []any { + if v == nil { + return nil + } + + arr, ok := v.(primitive.A) + if !ok { + // Try regular slice + if slice, ok := v.([]any); ok { + // Check if first element is the array type indicator + if len(slice) > 0 { + if typeIndicator, ok := slice[0].(int32); ok && (typeIndicator == 2 || typeIndicator == 3) { + // Skip the type indicator + return slice[1:] + } + } + return slice + } + return nil + } + + // primitive.A is []interface{} underneath + slice := []any(arr) + + // Check if first element is the array type indicator (2 or 3) + if len(slice) > 0 { + if typeIndicator, ok := slice[0].(int32); ok && (typeIndicator == 2 || typeIndicator == 3) { + // Skip the type indicator + return slice[1:] + } + } + + return slice +} + +// extractBsonMap coerces a BSON value to map[string]interface{}. +// Handles map[string]interface{}, primitive.D, and primitive.M. +func extractBsonMap(v any) map[string]any { + if v == nil { + return nil + } + switch val := v.(type) { + case map[string]any: + return val + case primitive.D: + return val.Map() + case primitive.M: + return map[string]any(val) + } + return nil +} + +// extractBsonSlice coerces a BSON value to []interface{}. +// Handles []interface{} and primitive.A. Unlike extractBsonArray, +// this does NOT strip Mendix type-indicator prefixes. +func extractBsonSlice(v any) []any { + if v == nil { + return nil + } + switch val := v.(type) { + case []any: + return val + case primitive.A: + return []any(val) + } + return nil +} + +// BsonArrayInfo holds the extracted items and the marker from a Mendix BSON array. +type BsonArrayInfo struct { + Marker int32 + Items []any +} + +// extractBsonArrayWithMarker extracts items from a Mendix BSON array, preserving the marker. +// Returns the marker (2 or 3) and the items after the marker. +func extractBsonArrayWithMarker(v any) BsonArrayInfo { + if v == nil { + return BsonArrayInfo{} + } + + var slice []any + switch val := v.(type) { + case primitive.A: + slice = []any(val) + case []any: + slice = val + default: + return BsonArrayInfo{} + } + + if len(slice) > 0 { + if marker, ok := slice[0].(int32); ok && (marker == 1 || marker == 2 || marker == 3) { + return BsonArrayInfo{Marker: marker, Items: slice[1:]} + } + } + return BsonArrayInfo{Items: slice} +} + +// inferPropertyKind determines the Mendix property kind of a BSON field from its key +// and value shape. Returns one of: "id", "type-discriminator", "by-name-reference", +// "primitive", "part", "collection:by-name" (marker=1), "collection:part-secondary" +// (marker=2), "collection:part-primary" (marker=3), "collection". +// Used by UnknownElement to surface diagnostic info when an unimplemented $Type is encountered. +func inferPropertyKind(key string, v any) string { + if v == nil { + return "primitive" + } + + // Key-based shortcuts take priority over value shape. + switch key { + case "$ID", "$ContainerID": + return "id" + case "$Type": + return "type-discriminator" + } + + switch val := v.(type) { + case map[string]any: + if _, hasType := val["$Type"]; hasType { + return "part" + } + if _, hasID := val["$ID"]; hasID { + return "part" + } + return "primitive" + + case primitive.D: + m := val.Map() + if _, hasType := m["$Type"]; hasType { + return "part" + } + if _, hasID := m["$ID"]; hasID { + return "part" + } + return "primitive" + + case primitive.M: + if _, hasType := val["$Type"]; hasType { + return "part" + } + if _, hasID := val["$ID"]; hasID { + return "part" + } + return "primitive" + + case primitive.A, []any: + info := extractBsonArrayWithMarker(v) + switch info.Marker { + case 1: + return "collection:by-name" + case 2: + return "collection:part-secondary" + case 3: + return "collection:part-primary" + } + return "collection" + + case string: + // Heuristic: qualified names like "Module.Entity" are likely by-name references. + if strings.Contains(val, ".") && !strings.Contains(val, " ") && !strings.Contains(val, "/") { + return "by-name-reference" + } + return "primitive" + + default: + return "primitive" + } +} diff --git a/modelsdk/mpr/reader.go b/modelsdk/mpr/reader.go new file mode 100644 index 00000000..7b50a047 --- /dev/null +++ b/modelsdk/mpr/reader.go @@ -0,0 +1,305 @@ +// SPDX-License-Identifier: Apache-2.0 + +// Package mpr provides functionality for reading and writing Mendix project files (.mpr). +package mpr + +import ( + "database/sql" + "encoding/hex" + "errors" + "fmt" + "os" + "path/filepath" + + "github.com/mendixlabs/mxcli/modelsdk/mpr/version" + + _ "modernc.org/sqlite" +) + +// MPRVersion represents the MPR file format version. +type MPRVersion int + +const ( + // MPRVersionV1 is the original single-file format. + MPRVersionV1 MPRVersion = 1 + // MPRVersionV2 uses mprcontents folder (Mendix 10.18+). + MPRVersionV2 MPRVersion = 2 +) + +// Reader provides methods to read Mendix project files. +type Reader struct { + path string + db *sql.DB + version MPRVersion + contentsDir string + readOnly bool + projectVersion *version.ProjectVersion + + // Cache for unit metadata to avoid repeated file reads + unitCache []cachedUnit + unitCacheValid bool +} + +// cachedUnit stores metadata about a unit for fast filtering. +type cachedUnit struct { + ID string + ContainerID string + ContainmentName string + Type string +} + +// OpenOptions configures how the MPR file is opened. +type OpenOptions struct { + // ReadOnly opens the database in read-only mode. + ReadOnly bool +} + +// Open opens an MPR file for reading. +func Open(path string) (*Reader, error) { + return OpenWithOptions(path, OpenOptions{ReadOnly: true}) +} + +// OpenWithOptions opens an MPR file with the specified options. +func OpenWithOptions(path string, opts OpenOptions) (*Reader, error) { + if _, err := os.Stat(path); os.IsNotExist(err) { + return nil, fmt.Errorf("mpr file not found: %s", path) + } + + r := &Reader{ + path: path, + readOnly: opts.ReadOnly, + } + + // Check for MPR v2 (mprcontents folder) + dir := filepath.Dir(path) + contentsDir := filepath.Join(dir, "mprcontents") + if stat, err := os.Stat(contentsDir); err == nil && stat.IsDir() { + r.version = MPRVersionV2 + r.contentsDir = contentsDir + } else { + r.version = MPRVersionV1 + } + + // Open SQLite database + dsn := path + if opts.ReadOnly { + dsn = fmt.Sprintf("file:%s?mode=ro", path) + } + + db, err := sql.Open("sqlite", dsn) + if err != nil { + return nil, fmt.Errorf("failed to open database: %w", err) + } + + // Limit to single connection to avoid lock contention with SQLite + db.SetMaxOpenConns(1) + + // Set busy timeout to prevent SQLITE_BUSY errors during multi-statement + // script execution (e.g., 12+ CREATE PAGE commands in sequence) + if _, err := db.Exec("PRAGMA busy_timeout = 5000"); err != nil { + db.Close() + return nil, fmt.Errorf("failed to set busy_timeout: %w", err) + } + + r.db = db + + // Detect project version from metadata + pv, err := version.DetectFromDB(db) + if err != nil { + r.Close() + return nil, fmt.Errorf("failed to detect project version: %w", err) + } + r.projectVersion = pv + + // Reconcile version detection: the folder-based check can fail if the .mpr + // file was copied without the mprcontents/ folder. Check the actual DB schema + // to determine whether the Unit table has a Contents column. If it doesn't, + // we must use v2 code paths to avoid "no such column: Contents" errors. + if r.version == MPRVersionV1 && !r.unitTableHasContents() { + dir := filepath.Dir(path) + contentsDir := filepath.Join(dir, "mprcontents") + r.version = MPRVersionV2 + r.contentsDir = contentsDir + } + + // Verify it's a valid MPR file + if err := r.verify(); err != nil { + r.Close() + return nil, err + } + + return r, nil +} + +// Close closes the reader and releases resources. +func (r *Reader) Close() error { + if r.db != nil { + return r.db.Close() + } + return nil +} + +// unitTableHasContents checks whether the Unit table has a Contents column. +// MPR v2 schemas (Mendix 10.18+) drop this column; v1 schemas have it. +func (r *Reader) unitTableHasContents() bool { + rows, err := r.db.Query("PRAGMA table_info(Unit)") + if err != nil { + return false + } + defer rows.Close() + for rows.Next() { + var cid int + var name, colType string + var notNull, pk int + var dfltValue *string + if err := rows.Scan(&cid, &name, &colType, ¬Null, &dfltValue, &pk); err != nil { + continue + } + if name == "Contents" { + return true + } + } + return false +} + +// Path returns the path to the MPR file. +func (r *Reader) Path() string { + return r.path +} + +// Version returns the MPR file format version. +func (r *Reader) Version() MPRVersion { + return r.version +} + +// ContentsDir returns the path to the mprcontents directory for v2 format. +// Returns empty string for v1 format. +func (r *Reader) ContentsDir() string { + return r.contentsDir +} + +// DB returns the underlying database connection. +func (r *Reader) DB() *sql.DB { + return r.db +} + +// ListAllUnitIDs returns all unit UUIDs from the Unit table. +func (r *Reader) ListAllUnitIDs() ([]string, error) { + rows, err := r.db.Query("SELECT UnitID FROM Unit") + if err != nil { + return nil, err + } + defer rows.Close() + var ids []string + for rows.Next() { + var unitID []byte + if err := rows.Scan(&unitID); err != nil { + return nil, fmt.Errorf("scanning unit ID: %w", err) + } + ids = append(ids, BlobToUUID(unitID)) + } + return ids, rows.Err() +} + +// ProjectVersion returns the Mendix project version information. +func (r *Reader) ProjectVersion() *version.ProjectVersion { + return r.projectVersion +} + +// verify checks that the file is a valid MPR database. +func (r *Reader) verify() error { + // Check for Unit table which is required + var count int + err := r.db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name = 'Unit'").Scan(&count) + if err != nil { + return fmt.Errorf("failed to query tables: %w", err) + } + if count == 0 { + return errors.New("not a valid MPR file: Unit table not found") + } + return nil +} + +// GetProjectRootID returns the ID of the project root unit. +// The project root is the unit where UnitID equals ContainerID. +func (r *Reader) GetProjectRootID() (string, error) { + var unitID []byte + err := r.db.QueryRow("SELECT UnitID FROM Unit WHERE UnitID = ContainerID").Scan(&unitID) + if err != nil { + return "", fmt.Errorf("failed to get project root: %w", err) + } + return blobToUUID(unitID), nil +} + +// GetMendixVersion returns the Mendix version used to create the project. +func (r *Reader) GetMendixVersion() (string, error) { + var version string + // Try new schema first + err := r.db.QueryRow("SELECT _ProductVersion FROM _MetaData LIMIT 1").Scan(&version) + if err != nil { + // Try old schema + err = r.db.QueryRow("SELECT MendixVersion FROM _MetaData LIMIT 1").Scan(&version) + if err != nil { + return "", fmt.Errorf("failed to get Mendix version: %w", err) + } + } + return version, nil +} + +// GetRawUnitBytes returns the raw BSON bytes for a unit identified by its UUID string. +func (r *Reader) GetRawUnitBytes(unitID string) ([]byte, error) { + if r.version == MPRVersionV2 { + // For v2, we need the swapped UUID to build the file path. + // The unitID is in standard UUID format; readMprContents expects + // the swapped format used by blobToUUID during cache building. + // Convert: UUID string → blob → swapped UUID. + blob := uuidToBlob(unitID) + if blob == nil { + return nil, fmt.Errorf("invalid unit ID: %s", unitID) + } + swapped := blobToUUIDSwapped(blob) + return r.readMprContents(swapped) + } + + // V1: read from database + blob := uuidToBlob(unitID) + if blob == nil { + return nil, fmt.Errorf("invalid unit ID: %s", unitID) + } + var contents []byte + err := r.db.QueryRow("SELECT Contents FROM Unit WHERE UnitID = ?", blob).Scan(&contents) + if err != nil { + return nil, fmt.Errorf("unit not found: %s", unitID) + } + return contents, nil +} + +// blobToUUID converts a 16-byte blob to a UUID string using Microsoft GUID format. +// The first 3 groups are little-endian (byte-swapped), last 2 groups are big-endian. +// This is the standard format used by Mendix for all UUID representations. +func blobToUUID(blob []byte) string { + if len(blob) != 16 { + return hex.EncodeToString(blob) + } + return fmt.Sprintf("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + blob[3], blob[2], blob[1], blob[0], + blob[5], blob[4], + blob[7], blob[6], + blob[8], blob[9], + blob[10], blob[11], blob[12], blob[13], blob[14], blob[15]) +} + +// blobToUUIDSwapped converts a 16-byte blob to a UUID string using Microsoft GUID format. +// The first 3 groups are little-endian (byte-swapped), last 2 groups are big-endian. +// This is the format used by Mendix for file naming in mprcontents folder. +func blobToUUIDSwapped(blob []byte) string { + if len(blob) != 16 { + return hex.EncodeToString(blob) + } + return fmt.Sprintf("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + blob[3], blob[2], blob[1], blob[0], + blob[5], blob[4], + blob[7], blob[6], + blob[8], blob[9], + blob[10], blob[11], blob[12], blob[13], blob[14], blob[15]) +} diff --git a/modelsdk/mpr/reader_units.go b/modelsdk/mpr/reader_units.go new file mode 100644 index 00000000..e0e4a562 --- /dev/null +++ b/modelsdk/mpr/reader_units.go @@ -0,0 +1,250 @@ +// SPDX-License-Identifier: Apache-2.0 + +// Package mpr - Unit listing infrastructure for Reader. +package mpr + +import ( + "fmt" + "os" + "path/filepath" + "strings" + + "go.mongodb.org/mongo-driver/bson" +) + +// ResolveModuleName walks the container hierarchy upward until it finds a module. +// This is necessary because in MPR v2 projects, documents live inside folders, +// so a document's direct ContainerID is a folder, not the module. +func ResolveModuleName(containerID string, moduleMap map[string]string, containerParent map[string]string) string { + current := containerID + for range 20 { + if name, ok := moduleMap[current]; ok { + return name + } + parent, ok := containerParent[current] + if !ok || parent == current { + break + } + current = parent + } + return "" +} + +// BuildContainerParent builds a map of unit ID → parent container ID for hierarchy walking. +func (r *Reader) BuildContainerParent() (map[string]string, error) { + units, err := r.ListUnits() + if err != nil { + return nil, err + } + containerParent := make(map[string]string, len(units)) + for _, u := range units { + containerParent[string(u.ID)] = string(u.ContainerID) + } + return containerParent, nil +} + +// rawUnit holds raw unit data from the database. +type rawUnit struct { + ID string + ContainerID string + ContainmentName string + Type string + Contents []byte +} + +// UnitRef holds unit metadata returned by ListUnitsByType. +type UnitRef struct { + ID string + ContainerID string + Type string // BSON $Type (e.g. "Microflows$Microflow") + Contents []byte +} + +// ListUnitsByType returns all units matching the given BSON $Type prefix. +// This is the exported version for use by TreeWriter and other packages. +func (r *Reader) ListUnitsByType(typePrefix string) ([]UnitRef, error) { + units, err := r.listUnitsByType(typePrefix) + if err != nil { + return nil, err + } + result := make([]UnitRef, len(units)) + for i, u := range units { + result[i] = UnitRef{ID: u.ID, ContainerID: u.ContainerID, Type: u.Type, Contents: u.Contents} + } + return result, nil +} + +// listUnitsByType returns all units matching the given type prefix. +func (r *Reader) listUnitsByType(typePrefix string) ([]rawUnit, error) { + if r.version == MPRVersionV2 { + return r.listUnitsByTypeV2(typePrefix) + } + return r.listUnitsByTypeV1(typePrefix) +} + +// listUnitsByTypeV1 handles MPR v1 format (contents in database). +func (r *Reader) listUnitsByTypeV1(typePrefix string) ([]rawUnit, error) { + rows, err := r.db.Query(` + SELECT UnitID, ContainerID, ContainmentName, Contents + FROM Unit + `) + if err != nil { + return nil, fmt.Errorf("failed to query units: %w", err) + } + defer rows.Close() + + var units []rawUnit + for rows.Next() { + var unitID, containerID []byte + var containmentName string + var contents []byte + + if err := rows.Scan(&unitID, &containerID, &containmentName, &contents); err != nil { + return nil, fmt.Errorf("failed to scan unit row: %w", err) + } + + typeName := getTypeFromContents(contents) + if typePrefix == "" || strings.HasPrefix(typeName, typePrefix) { + units = append(units, rawUnit{ + ID: blobToUUID(unitID), + ContainerID: blobToUUID(containerID), + ContainmentName: containmentName, + Type: typeName, + Contents: contents, + }) + } + } + + return units, nil +} + +// listUnitsByTypeV2 handles MPR v2 format (contents in mprcontents folder). +// Uses caching to avoid reading every file for each query. +func (r *Reader) listUnitsByTypeV2(typePrefix string) ([]rawUnit, error) { + // Build cache if not valid + if !r.unitCacheValid { + if err := r.buildUnitCache(); err != nil { + return nil, err + } + } + + // Filter by type using cache, only read contents for matching units + var units []rawUnit + for _, cu := range r.unitCache { + if typePrefix == "" || strings.HasPrefix(cu.Type, typePrefix) { + // Read contents from mprcontents folder + // Note: cu.ID is already in the correct swapped format from blobToUUID + contents, err := r.readMprContents(cu.ID) + if err != nil { + // Skip units with missing content files + continue + } + + units = append(units, rawUnit{ + ID: cu.ID, + ContainerID: cu.ContainerID, + ContainmentName: cu.ContainmentName, + Type: cu.Type, + Contents: contents, + }) + } + } + + return units, nil +} + +// buildUnitCache reads all unit metadata once and caches it. +func (r *Reader) buildUnitCache() error { + rows, err := r.db.Query(` + SELECT UnitID, ContainerID, ContainmentName + FROM Unit + `) + if err != nil { + return fmt.Errorf("failed to query units: %w", err) + } + defer rows.Close() + + r.unitCache = nil + for rows.Next() { + var unitID, containerID []byte + var containmentName string + + if err := rows.Scan(&unitID, &containerID, &containmentName); err != nil { + return fmt.Errorf("failed to scan unit row: %w", err) + } + + // Convert UnitID to UUID string + unitUUID := blobToUUID(unitID) + + // Read contents to get type (only done once during cache build) + contents, err := r.readMprContents(unitUUID) + if err != nil { + // Skip units with missing content files + continue + } + + typeName := getTypeFromContents(contents) + r.unitCache = append(r.unitCache, cachedUnit{ + ID: blobToUUID(unitID), + ContainerID: blobToUUID(containerID), + ContainmentName: containmentName, + Type: typeName, + }) + } + + r.unitCacheValid = true + return nil +} + +// InvalidateCache marks the unit cache as invalid. +// Should be called after any write operation. +func (r *Reader) InvalidateCache() { + r.unitCacheValid = false +} + +// readMprContents reads content from the mprcontents folder for v2 format. +// The path is: mprcontents/XX/YY/UUID.mxunit where XX and YY are first two chars of UUID. +func (r *Reader) readMprContents(unitUUID string) ([]byte, error) { + if len(unitUUID) < 4 { + return nil, fmt.Errorf("invalid unit UUID: %s", unitUUID) + } + + // Build path: mprcontents/XX/YY/UUID.mxunit + // UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + // First two chars are positions 0-1, next two are positions 2-3 + path := filepath.Join( + r.contentsDir, + unitUUID[0:2], + unitUUID[2:4], + unitUUID+".mxunit", + ) + + return os.ReadFile(path) +} + +// getTypeFromContents extracts the $Type field from BSON contents. +// Uses bson.Raw.LookupErr for O(1) field extraction instead of unmarshalling +// the entire document into map[string]any. +func getTypeFromContents(contents []byte) string { + if len(contents) == 0 { + return "" + } + val, err := bson.Raw(contents).LookupErr("$Type") + if err != nil { + return "" + } + s, ok := val.StringValueOK() + if !ok { + return "" + } + return s +} + +// RawUnitInfo contains information about a raw unit for BSON debugging. +type RawUnitInfo struct { + ID string + QualifiedName string + Type string + ModuleName string + Contents []byte +} diff --git a/modelsdk/mpr/system_module.go b/modelsdk/mpr/system_module.go new file mode 100644 index 00000000..1b1786cd --- /dev/null +++ b/modelsdk/mpr/system_module.go @@ -0,0 +1,13 @@ +// SPDX-License-Identifier: Apache-2.0 + +package mpr + +import "github.com/mendixlabs/mxcli/modelsdk/meta" + +// buildSystemModuleInfo returns a ModuleInfo for the virtual System module. +func buildSystemModuleInfo() *ModuleInfo { + return &ModuleInfo{ + ID: meta.SystemModuleID, + Name: "System", + } +} diff --git a/modelsdk/mpr/testdata/enumerations/PictureQuality.mxunit b/modelsdk/mpr/testdata/enumerations/PictureQuality.mxunit new file mode 100644 index 00000000..d9fa89f2 Binary files /dev/null and b/modelsdk/mpr/testdata/enumerations/PictureQuality.mxunit differ diff --git a/modelsdk/mpr/testdata/microflows/ChangePassword.mxunit b/modelsdk/mpr/testdata/microflows/ChangePassword.mxunit new file mode 100644 index 00000000..922464b4 Binary files /dev/null and b/modelsdk/mpr/testdata/microflows/ChangePassword.mxunit differ diff --git a/modelsdk/mpr/testdata/pages/Account_Overview.mxunit b/modelsdk/mpr/testdata/pages/Account_Overview.mxunit new file mode 100644 index 00000000..ab4004fc Binary files /dev/null and b/modelsdk/mpr/testdata/pages/Account_Overview.mxunit differ diff --git a/modelsdk/mpr/testdata/pages/WidgetDemo_Showcase.mxunit b/modelsdk/mpr/testdata/pages/WidgetDemo_Showcase.mxunit new file mode 100644 index 00000000..1035e09f Binary files /dev/null and b/modelsdk/mpr/testdata/pages/WidgetDemo_Showcase.mxunit differ diff --git a/modelsdk/mpr/testdata/workflows/WorkflowBaseline.Sub_Workflow.bson b/modelsdk/mpr/testdata/workflows/WorkflowBaseline.Sub_Workflow.bson new file mode 100644 index 00000000..19251a06 Binary files /dev/null and b/modelsdk/mpr/testdata/workflows/WorkflowBaseline.Sub_Workflow.bson differ diff --git a/modelsdk/mpr/testdata/workflows/WorkflowBaseline.Workflow.bson b/modelsdk/mpr/testdata/workflows/WorkflowBaseline.Workflow.bson new file mode 100644 index 00000000..57106943 Binary files /dev/null and b/modelsdk/mpr/testdata/workflows/WorkflowBaseline.Workflow.bson differ diff --git a/modelsdk/mpr/types.go b/modelsdk/mpr/types.go new file mode 100644 index 00000000..222f6d70 --- /dev/null +++ b/modelsdk/mpr/types.go @@ -0,0 +1,146 @@ +package mpr + +import ( + "fmt" + "os" + "path/filepath" + + "go.mongodb.org/mongo-driver/bson" +) + +// UnitInfo contains basic information about a unit. +type UnitInfo struct { + ID string + ContainerID string + ContainmentName string + Type string +} + +// FolderInfo contains information about a project folder. +type FolderInfo struct { + ID string + ContainerID string + Name string +} + +// ModuleInfo contains basic information about a module. +type ModuleInfo struct { + ID string + Name string +} + +// ListModules returns all modules in the project. +func (r *Reader) ListModules() ([]*ModuleInfo, error) { + units, err := r.listUnitsByType("Projects$ModuleImpl") + if err != nil { + return nil, err + } + var modules []*ModuleInfo + for _, u := range units { + contents, err := r.resolveContents(u.ID, u.Contents) + if err != nil { + continue + } + var raw map[string]any + if err := bson.Unmarshal(contents, &raw); err != nil { + continue + } + name, _ := raw["Name"].(string) + modules = append(modules, &ModuleInfo{ID: u.ID, Name: name}) + } + modules = append(modules, buildSystemModuleInfo()) + return modules, nil +} + +// GetModule retrieves a module by ID. +func (r *Reader) GetModule(id string) (*ModuleInfo, error) { + modules, err := r.ListModules() + if err != nil { + return nil, err + } + for _, m := range modules { + if m.ID == id { + return m, nil + } + } + return nil, fmt.Errorf("module not found: %s", id) +} + +// GetModuleByName retrieves a module by name. +func (r *Reader) GetModuleByName(name string) (*ModuleInfo, error) { + modules, err := r.ListModules() + if err != nil { + return nil, err + } + for _, m := range modules { + if m.Name == name { + return m, nil + } + } + return nil, fmt.Errorf("module not found: %s", name) +} + +// ListUnits returns all units with their IDs and types. +func (r *Reader) ListUnits() ([]*UnitInfo, error) { + units, err := r.listUnitsByType("") + if err != nil { + return nil, err + } + var result []*UnitInfo + for _, u := range units { + result = append(result, &UnitInfo{ + ID: u.ID, + ContainerID: u.ContainerID, + ContainmentName: u.ContainmentName, + Type: u.Type, + }) + } + return result, nil +} + +// ListFolders returns all project folders with their names. +func (r *Reader) ListFolders() ([]*FolderInfo, error) { + units, err := r.listUnitsByType("Projects$Folder") + if err != nil { + return nil, err + } + var result []*FolderInfo + for _, u := range units { + name := "" + if len(u.Contents) > 0 { + var raw map[string]any + if err := bson.Unmarshal(u.Contents, &raw); err == nil { + if n, ok := raw["Name"].(string); ok { + name = n + } + } + } + result = append(result, &FolderInfo{ + ID: u.ID, + ContainerID: u.ContainerID, + Name: name, + }) + } + return result, nil +} + +// resolveContents resolves unit contents, loading from external file for MPR v2. +func (r *Reader) resolveContents(unitID string, contents []byte) ([]byte, error) { + if r.version == MPRVersionV1 { + return contents, nil + } + if len(contents) >= 4 { + return contents, nil + } + externalPath := filepath.Join(r.contentsDir, unitID) + if _, err := os.Stat(externalPath); err == nil { + return os.ReadFile(externalPath) + } + for _, ext := range []string{".mxunit", ".json", ""} { + path := filepath.Join(r.contentsDir, unitID+ext) + if data, err := os.ReadFile(path); err == nil { + return data, nil + } + } + return contents, nil +} diff --git a/modelsdk/mpr/utils.go b/modelsdk/mpr/utils.go new file mode 100644 index 00000000..ffca1a2a --- /dev/null +++ b/modelsdk/mpr/utils.go @@ -0,0 +1,68 @@ +// SPDX-License-Identifier: Apache-2.0 + +package mpr + +import ( + "crypto/sha256" + "fmt" + + "go.mongodb.org/mongo-driver/bson/primitive" +) + +// GenerateID generates a new unique ID for model elements. +func GenerateID() string { + return generateUUID() +} + +// GenerateDeterministicID generates a stable UUID from a seed string. +// Used for System module entities that aren't in the MPR but need consistent IDs. +func GenerateDeterministicID(seed string) string { + h := sha256.Sum256([]byte(seed)) + return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", + h[0:4], h[4:6], h[6:8], h[8:10], h[10:16]) +} + +// BlobToUUID converts a binary ID blob to a UUID string. +func BlobToUUID(data []byte) string { + return blobToUUID(data) +} + +// IDToBsonBinary converts a UUID string to a BSON binary value. +func IDToBsonBinary(id string) primitive.Binary { + return idToBsonBinary(id) +} + +// BsonBinaryToID converts a BSON binary value to a UUID string. +func BsonBinaryToID(bin primitive.Binary) string { + return BlobToUUID(bin.Data) +} + +// Hash computes a hash for content (used for content deduplication). +func Hash(content []byte) string { + // Simple hash for now - could use crypto/sha256 for better hashing + var sum uint64 + for i, b := range content { + sum += uint64(b) * uint64(i+1) + } + return fmt.Sprintf("%016x", sum) +} + +// ValidateID checks if an ID is valid. +func ValidateID(id string) bool { + if len(id) != 36 { + return false + } + // Check UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + for i, c := range id { + if i == 8 || i == 13 || i == 18 || i == 23 { + if c != '-' { + return false + } + } else { + if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) { + return false + } + } + } + return true +} diff --git a/modelsdk/mpr/version/version.go b/modelsdk/mpr/version/version.go new file mode 100644 index 00000000..ba387b6a --- /dev/null +++ b/modelsdk/mpr/version/version.go @@ -0,0 +1,190 @@ +// SPDX-License-Identifier: Apache-2.0 + +// Package version provides Mendix project version detection and handling. +package version + +import ( + "database/sql" + "fmt" + "strconv" + "strings" +) + +// ProjectVersion contains version information for a Mendix project. +type ProjectVersion struct { + // ProductVersion is the full Mendix version string (e.g., "10.18.0", "11.6.0") + ProductVersion string + + // BuildVersion is the build version, usually same as ProductVersion + BuildVersion string + + // FormatVersion is the MPR format version (1 for legacy, 2 for mprcontents) + FormatVersion int + + // SchemaHash is the SHA256 hash of the metamodel schema + SchemaHash string + + // MajorVersion is the major version number (e.g., 10, 11) + MajorVersion int + + // MinorVersion is the minor version number (e.g., 18, 6) + MinorVersion int + + // PatchVersion is the patch version number (e.g., 0, 1) + PatchVersion int +} + +// DefaultVersion returns the default version (11.6.0) used when detection fails. +func DefaultVersion() *ProjectVersion { + return &ProjectVersion{ + ProductVersion: "11.6.0", + BuildVersion: "11.6.0", + FormatVersion: 2, + MajorVersion: 11, + MinorVersion: 6, + PatchVersion: 0, + } +} + +// DetectFromDB reads version information from the MPR database. +func DetectFromDB(db *sql.DB) (*ProjectVersion, error) { + var formatVersion int + var productVersion, buildVersion, schemaHash string + + // Try the old schema first (with _FormatVersion) + row := db.QueryRow("SELECT _FormatVersion, _ProductVersion, _BuildVersion, _SchemaHash FROM _MetaData LIMIT 1") + err := row.Scan(&formatVersion, &productVersion, &buildVersion, &schemaHash) + if err != nil { + if err == sql.ErrNoRows { + // Return default if no metadata found + return DefaultVersion(), nil + } + // Try new schema without _FormatVersion (Mendix 11.6.2+) + row = db.QueryRow("SELECT _ProductVersion, _BuildVersion, _SchemaHash FROM _MetaData LIMIT 1") + err = row.Scan(&productVersion, &buildVersion, &schemaHash) + if err != nil { + if err == sql.ErrNoRows { + return DefaultVersion(), nil + } + return nil, fmt.Errorf("failed to read version metadata: %w", err) + } + // Default format version to 2 for newer schemas + formatVersion = 2 + } + + pv := &ProjectVersion{ + ProductVersion: productVersion, + BuildVersion: buildVersion, + FormatVersion: formatVersion, + SchemaHash: schemaHash, + } + + // Parse version components + pv.MajorVersion, pv.MinorVersion, pv.PatchVersion = parseVersion(productVersion) + + return pv, nil +} + +// parseVersion extracts major, minor, patch from a version string like "10.18.0" +func parseVersion(version string) (major, minor, patch int) { + parts := strings.Split(version, ".") + if len(parts) >= 1 { + major, _ = strconv.Atoi(parts[0]) + } + if len(parts) >= 2 { + minor, _ = strconv.Atoi(parts[1]) + } + if len(parts) >= 3 { + patch, _ = strconv.Atoi(parts[2]) + } + return +} + +// String returns the product version string. +func (v *ProjectVersion) String() string { + return v.ProductVersion +} + +// IsMPRv2 returns true if the project uses MPR v2 format (mprcontents folder). +func (v *ProjectVersion) IsMPRv2() bool { + return v.FormatVersion >= 2 +} + +// IsAtLeast returns true if this version is at least the specified major.minor version. +func (v *ProjectVersion) IsAtLeast(major, minor int) bool { + if v.MajorVersion > major { + return true + } + if v.MajorVersion == major && v.MinorVersion >= minor { + return true + } + return false +} + +// IsAtLeastFull returns true if this version is at least the specified major.minor.patch version. +func (v *ProjectVersion) IsAtLeastFull(major, minor, patch int) bool { + if v.MajorVersion > major { + return true + } + if v.MajorVersion == major && v.MinorVersion > minor { + return true + } + if v.MajorVersion == major && v.MinorVersion == minor && v.PatchVersion >= patch { + return true + } + return false +} + +// SupportedVersionRange defines the range of Mendix versions supported for read/write. +var SupportedVersionRange = struct { + MinMajor int + MaxMajor int +}{ + MinMajor: 9, + MaxMajor: 11, +} + +// IsSupported returns true if this version is within the supported range for writing. +func (v *ProjectVersion) IsSupported() bool { + return v.MajorVersion >= SupportedVersionRange.MinMajor && + v.MajorVersion <= SupportedVersionRange.MaxMajor +} + +// SupportsFeature checks if a specific feature is available in this version. +func (v *ProjectVersion) SupportsFeature(feature Feature) bool { + minVersion, ok := featureVersions[feature] + if !ok { + return false + } + return v.IsAtLeast(minVersion.Major, minVersion.Minor) +} + +// Feature represents a Mendix feature that may or may not be available. +type Feature string + +// Known features with version requirements +const ( + FeatureViewEntities Feature = "ViewEntities" + FeatureAssociationStorage Feature = "AssociationStorageFormat" + FeatureMPRv2 Feature = "MPRv2Format" + FeatureBusinessEvents Feature = "BusinessEvents" + FeatureWorkflows Feature = "Workflows" + FeaturePortableApp Feature = "PortableApp" +) + +// MinVersion represents a minimum version requirement. +type MinVersion struct { + Major int + Minor int +} + +// featureVersions maps features to their minimum required versions. +// This is the fallback when the YAML registry is unavailable. +var featureVersions = map[Feature]MinVersion{ + FeatureViewEntities: {Major: 10, Minor: 18}, + FeatureAssociationStorage: {Major: 11, Minor: 0}, + FeatureMPRv2: {Major: 10, Minor: 18}, + FeatureBusinessEvents: {Major: 10, Minor: 0}, + FeatureWorkflows: {Major: 9, Minor: 0}, + FeaturePortableApp: {Major: 11, Minor: 6}, +} diff --git a/modelsdk/mpr/writer_core.go b/modelsdk/mpr/writer_core.go new file mode 100644 index 00000000..0e4fd2ee --- /dev/null +++ b/modelsdk/mpr/writer_core.go @@ -0,0 +1,540 @@ +// SPDX-License-Identifier: Apache-2.0 + +package mpr + +import ( + "bytes" + "crypto/rand" + "crypto/sha256" + "database/sql" + "encoding/base64" + "encoding/hex" + "fmt" + "os" + "path/filepath" + "strings" + + "log" + + "go.mongodb.org/mongo-driver/bson/primitive" +) + +// idToBsonBinary converts a UUID string to BSON Binary format. +// Mendix stores IDs as Binary with Subtype 0. +func idToBsonBinary(id string) primitive.Binary { + blob := uuidToBlob(id) + if blob == nil || len(blob) != 16 { + // Generate a new UUID if the provided one is invalid + blob = uuidToBlob(generateUUID()) + } + return primitive.Binary{ + Subtype: 0x00, + Data: blob, + } +} + +// Writer provides methods to write Mendix project files. +type Writer struct { + reader *Reader +} + +// NewWriter creates a new writer from a reader opened in read-write mode. +func NewWriter(path string) (*Writer, error) { + reader, err := OpenWithOptions(path, OpenOptions{ReadOnly: false}) + if err != nil { + return nil, err + } + return &Writer{reader: reader}, nil +} + +// Close closes the writer. +func (w *Writer) Close() error { + return w.reader.Close() +} + +// Reader returns the underlying reader. +func (w *Writer) Reader() *Reader { + return w.reader +} + +// Transaction support + +// Transaction represents a database transaction. +type Transaction struct { + tx *sql.Tx + writer *Writer +} + +// BeginTransaction starts a new transaction. +func (w *Writer) BeginTransaction() (*Transaction, error) { + tx, err := w.reader.db.Begin() + if err != nil { + return nil, err + } + return &Transaction{tx: tx, writer: w}, nil +} + +// Commit commits the transaction. +func (t *Transaction) Commit() error { + return t.tx.Commit() +} + +// Rollback rolls back the transaction. +func (t *Transaction) Rollback() error { + return t.tx.Rollback() +} + +// WriteTransaction provides atomic write operations for MPR v2 format. +// It coordinates database and file system changes to ensure consistency. +type WriteTransaction struct { + tx *sql.Tx + writer *Writer + pendingFiles []pendingFile + committed bool +} + +type pendingFile struct { + tempPath string + finalPath string +} + +// BeginWriteTransaction starts a new write transaction. +// For v2 format, this coordinates both database and file writes. +func (w *Writer) BeginWriteTransaction() (*WriteTransaction, error) { + tx, err := w.reader.db.Begin() + if err != nil { + return nil, err + } + return &WriteTransaction{ + tx: tx, + writer: w, + pendingFiles: make([]pendingFile, 0), + }, nil +} + +// WriteUnit writes a unit within the transaction. +// The actual file write is deferred until Commit. +func (wt *WriteTransaction) WriteUnit(unitID string, contents []byte) error { + unitIDBlob := uuidToBlob(unitID) + + if wt.writer.reader.version == MPRVersionV2 { + swappedUUID := blobToUUIDSwapped(unitIDBlob) + + // Create directory if needed + dir := filepath.Join(wt.writer.reader.contentsDir, swappedUUID[0:2], swappedUUID[2:4]) + if err := os.MkdirAll(dir, 0755); err != nil { + return fmt.Errorf("failed to create directory: %w", err) + } + + // Write to temp file first + finalPath := filepath.Join(dir, swappedUUID+".mxunit") + tempPath := finalPath + ".tmp" + + if err := os.WriteFile(tempPath, contents, 0644); err != nil { + return fmt.Errorf("failed to write temp file: %w", err) + } + + wt.pendingFiles = append(wt.pendingFiles, pendingFile{ + tempPath: tempPath, + finalPath: finalPath, + }) + + // Update hash in DB + hash := sha256.Sum256(contents) + contentsHash := base64.StdEncoding.EncodeToString(hash[:]) + _, err := wt.tx.Exec(` + UPDATE Unit SET ContentsHash = ? WHERE UnitID = ? + `, contentsHash, unitIDBlob) + return err + } + + // V1: Update in database directly + _, err := wt.tx.Exec(` + UPDATE Unit SET Contents = ? WHERE UnitID = ? + `, contents, unitIDBlob) + return err +} + +// Commit commits the transaction. +// For v2, this first commits the database, then finalizes file writes. +func (wt *WriteTransaction) Commit() error { + if wt.committed { + return fmt.Errorf("transaction already committed") + } + + // Commit database transaction first + if err := wt.tx.Commit(); err != nil { + // Clean up temp files + wt.cleanupTempFiles() + return err + } + + // Finalize file writes by renaming temp files to final paths + for _, pf := range wt.pendingFiles { + if err := os.Rename(pf.tempPath, pf.finalPath); err != nil { + // Log error but continue - DB is already committed + // This could leave some files in inconsistent state + log.Printf("mpr.finalize_failed: path=%s error=%s", pf.finalPath, err.Error()) + } + } + + wt.committed = true + // Invalidate reader cache so next read sees the updated data + wt.writer.reader.InvalidateCache() + return nil +} + +// Rollback rolls back the transaction and cleans up temp files. +func (wt *WriteTransaction) Rollback() error { + if wt.committed { + return fmt.Errorf("transaction already committed") + } + + // Clean up temp files + wt.cleanupTempFiles() + + // Rollback database + return wt.tx.Rollback() +} + +func (wt *WriteTransaction) cleanupTempFiles() { + for _, pf := range wt.pendingFiles { + os.Remove(pf.tempPath) + } +} + +// generateUUID generates a new UUID v4 for model elements. +// Returns format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx +func generateUUID() string { + b := make([]byte, 16) + _, _ = rand.Read(b) + b[6] = (b[6] & 0x0f) | 0x40 // Version 4 + b[8] = (b[8] & 0x3f) | 0x80 // Variant is 10 + + return fmt.Sprintf("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + b[0], b[1], b[2], b[3], + b[4], b[5], + b[6], b[7], + b[8], b[9], + b[10], b[11], b[12], b[13], b[14], b[15]) +} + +// DeleteChildUnits recursively deletes all units whose ContainerID matches parentID. +func (w *Writer) DeleteChildUnits(parentID string) error { + return w.deleteChildUnitsRecursive(parentID) +} + +func (w *Writer) deleteChildUnitsRecursive(parentID string) error { + parentBlob := uuidToBlob(parentID) + if parentBlob == nil { + return fmt.Errorf("invalid parent ID: %s", parentID) + } + + rows, err := w.reader.db.Query("SELECT UnitID FROM Unit WHERE ContainerID = ? AND UnitID != ContainerID", parentBlob) + if err != nil { + return err + } + defer rows.Close() + + var childIDs []string + for rows.Next() { + var childBlob []byte + if err := rows.Scan(&childBlob); err != nil { + return err + } + childIDs = append(childIDs, blobToUUID(childBlob)) + } + + for _, childID := range childIDs { + if err := w.deleteChildUnitsRecursive(childID); err != nil { + return err + } + if err := w.deleteUnit(childID); err != nil { + return err + } + } + + return nil +} + +// uuidToBlob converts a UUID string to a 16-byte blob in Microsoft GUID format. +// UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx +// Microsoft GUID format byte-swaps the first 3 groups (little-endian): +// - First 4 bytes: reversed +// - Next 2 bytes: reversed +// - Next 2 bytes: reversed +// - Last 8 bytes: unchanged +func uuidToBlob(uuid string) []byte { + if uuid == "" { + return nil + } + // Remove dashes + var clean strings.Builder + for _, c := range uuid { + if c != '-' { + clean.WriteString(string(c)) + } + } + // Decode hex to bytes + decoded, err := hex.DecodeString(clean.String()) + if err != nil || len(decoded) != 16 { + return nil + } + // Swap bytes to Microsoft GUID format + blob := make([]byte, 16) + // First 4 bytes: reversed + blob[0] = decoded[3] + blob[1] = decoded[2] + blob[2] = decoded[1] + blob[3] = decoded[0] + // Next 2 bytes: reversed + blob[4] = decoded[5] + blob[5] = decoded[4] + // Next 2 bytes: reversed + blob[6] = decoded[7] + blob[7] = decoded[6] + // Last 8 bytes: unchanged + copy(blob[8:], decoded[8:]) + return blob +} + +// --------------------------------------------------------------------------- +// Unit CRUD operations (merged from writer_units.go) +// --------------------------------------------------------------------------- + +// updateTransactionID updates the _Transaction table with a new UUID. +// Studio Pro uses this to detect external changes during F4 sync. +// Only applies to MPR v2 projects (Mendix >= 10.18). +func (w *Writer) updateTransactionID() { + if w.reader.version != MPRVersionV2 { + return + } + newID := generateUUID() + _, _ = w.reader.db.Exec(`UPDATE _Transaction SET LastTransactionID = ?`, newID) +} + +// placeholderBinaryPrefix is the GUID-swapped byte pattern for placeholder IDs generated +// by sdk/widgets/augment.go placeholderID(). These are "aa000000000000000000000000XXXXXX" +// hex strings which, after hex decode + GUID byte-swap, produce 16-byte blobs whose first +// 13 bytes are \x00\x00\x00\xaa followed by 9 zero bytes. +var placeholderBinaryPrefix = []byte{0x00, 0x00, 0x00, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} + +// placeholderStringPrefix is the ASCII prefix of a placeholder ID that leaked as a string. +var placeholderStringBytes = []byte("aa000000000000000000000000") + +// validateNoPlaceholderIDs scans raw BSON bytes for leaked placeholder IDs. +// Returns an error if any placeholder pattern is found. +func validateNoPlaceholderIDs(unitID string, contents []byte) error { + if bytes.Contains(contents, placeholderBinaryPrefix) { + return fmt.Errorf("placeholder ID leak detected in unit %s: binary aa000000-prefix ID found in BSON contents", unitID) + } + if bytes.Contains(contents, placeholderStringBytes) { + return fmt.Errorf("placeholder ID leak detected in unit %s: string aa000000-prefix ID found in BSON contents", unitID) + } + return nil +} + +func (w *Writer) insertUnit(unitID, containerID, containmentName, unitType string, contents []byte) error { + if err := validateNoPlaceholderIDs(unitID, contents); err != nil { + return err + } + + // Convert UUID strings to 16-byte blobs for database + unitIDBlob := uuidToBlob(unitID) + containerIDBlob := uuidToBlob(containerID) + + if unitIDBlob == nil { + return fmt.Errorf("invalid unit ID (not a valid UUID): %q", unitID) + } + if containerIDBlob == nil { + return fmt.Errorf("invalid container ID (not a valid UUID): %q", containerID) + } + + if w.reader.version == MPRVersionV2 { + // Get swapped UUID for file path + swappedUUID := blobToUUIDSwapped(unitIDBlob) + + // Create directory structure: mprcontents/XX/YY/ + dir := filepath.Join(w.reader.contentsDir, swappedUUID[0:2], swappedUUID[2:4]) + if err := os.MkdirAll(dir, 0755); err != nil { + return fmt.Errorf("failed to create directory %s: %w", dir, err) + } + + // Write content file + filePath := filepath.Join(dir, swappedUUID+".mxunit") + if err := os.WriteFile(filePath, contents, 0644); err != nil { + return fmt.Errorf("failed to write unit file: %w", err) + } + + // Compute content hash (base64-encoded SHA256) + hash := sha256.Sum256(contents) + contentsHash := base64.StdEncoding.EncodeToString(hash[:]) + + // Insert reference to database + _, err := w.reader.db.Exec(` + INSERT INTO Unit (UnitID, ContainerID, ContainmentName, TreeConflict, ContentsHash, ContentsConflicts) + VALUES (?, ?, ?, 0, ?, '') + `, unitIDBlob, containerIDBlob, containmentName, contentsHash) + if err != nil { + // Clean up the file we just wrote — otherwise it becomes an orphan + os.Remove(filePath) + return err + } + w.reader.InvalidateCache() + w.updateTransactionID() + return nil + } + + // MPR v1: Store directly in database + // Try new schema first (without Type column - Mendix 11.6.2+) + _, err := w.reader.db.Exec(` + INSERT INTO Unit (UnitID, ContainerID, ContainmentName, TreeConflict, ContentsHash, ContentsConflicts, Contents) + VALUES (?, ?, ?, 0, '', '', ?) + `, unitIDBlob, containerIDBlob, containmentName, contents) + if err != nil { + // Try old schema with Type column + _, err = w.reader.db.Exec(` + INSERT INTO Unit (UnitID, ContainerID, ContainmentName, Type, Contents) + VALUES (?, ?, ?, ?, ?) + `, unitIDBlob, containerIDBlob, containmentName, unitType, contents) + } + if err == nil { + w.reader.InvalidateCache() + } + return err +} + +func (w *Writer) updateUnit(unitID string, contents []byte) error { + if err := validateNoPlaceholderIDs(unitID, contents); err != nil { + return err + } + + // Convert UUID string to 16-byte blob + unitIDBlob := uuidToBlob(unitID) + + if w.reader.version == MPRVersionV2 { + // Get swapped UUID for file path + swappedUUID := blobToUUIDSwapped(unitIDBlob) + + // Build file path: mprcontents/XX/YY/UUID.mxunit + filePath := filepath.Join( + w.reader.contentsDir, + swappedUUID[0:2], + swappedUUID[2:4], + swappedUUID+".mxunit", + ) + + // Write updated content + if err := os.WriteFile(filePath, contents, 0644); err != nil { + return fmt.Errorf("failed to write unit file: %w", err) + } + + // Update ContentsHash in database + hash := sha256.Sum256(contents) + contentsHash := base64.StdEncoding.EncodeToString(hash[:]) + _, err := w.reader.db.Exec(` + UPDATE Unit SET ContentsHash = ? WHERE UnitID = ? + `, contentsHash, unitIDBlob) + if err == nil { + w.reader.InvalidateCache() + w.updateTransactionID() + } + return err + } + + // MPR v1: Update in database + _, err := w.reader.db.Exec(` + UPDATE Unit SET Contents = ? WHERE UnitID = ? + `, contents, unitIDBlob) + return err +} + +// UpdateRawUnit saves raw BSON bytes for a unit, bypassing deserialization. +// Used by ALTER PAGE to modify the BSON widget tree directly. +func (w *Writer) UpdateRawUnit(unitID string, contents []byte) error { + return w.updateUnit(unitID, contents) +} + +// InsertUnit creates a new unit in the project database. +// This is the exported version of insertUnit for use by TreeWriter and other packages. +func (w *Writer) InsertUnit(unitID, containerID, containmentName, unitType string, contents []byte) error { + return w.insertUnit(unitID, containerID, containmentName, unitType, contents) +} + +// DeleteUnit removes a unit from the project database. +// This is the exported version of deleteUnit for use by TreeWriter and other packages. +func (w *Writer) DeleteUnit(unitID string) error { + return w.deleteUnit(unitID) +} + +func (w *Writer) deleteUnit(unitID string) error { + // Convert UUID string to 16-byte blob + unitIDBlob := uuidToBlob(unitID) + if unitIDBlob == nil { + return fmt.Errorf("invalid unit ID: %s", unitID) + } + + if w.reader.version == MPRVersionV2 { + // Get swapped UUID for file path + swappedUUID := blobToUUIDSwapped(unitIDBlob) + + // Delete external file + subDir1 := swappedUUID[0:2] + subDir2 := swappedUUID[2:4] + filePath := filepath.Join(w.reader.contentsDir, subDir1, subDir2, swappedUUID+".mxunit") + os.Remove(filePath) // Ignore error if file doesn't exist + + // Clean up empty parent directories (YY/, then XX/) + dir2 := filepath.Join(w.reader.contentsDir, subDir1, subDir2) + os.Remove(dir2) // Only succeeds if empty + dir1 := filepath.Join(w.reader.contentsDir, subDir1) + os.Remove(dir1) // Only succeeds if empty + } + + result, err := w.reader.db.Exec(`DELETE FROM Unit WHERE UnitID = ?`, unitIDBlob) + if err != nil { + return err + } + + rowsAffected, err := result.RowsAffected() + if err != nil { + return fmt.Errorf("failed to get rows affected: %w", err) + } + + if rowsAffected == 0 { + return fmt.Errorf("unit not found in database: %s", unitID) + } + + w.reader.InvalidateCache() + w.updateTransactionID() + return nil +} + +// UpdateUnitContainer changes the ContainerID of a unit, moving it to a new parent. +func (w *Writer) UpdateUnitContainer(unitID, newContainerID string) error { + unitIDBlob := uuidToBlob(unitID) + if unitIDBlob == nil { + return fmt.Errorf("invalid unit ID: %s", unitID) + } + containerIDBlob := uuidToBlob(newContainerID) + if containerIDBlob == nil { + return fmt.Errorf("invalid container ID: %s", newContainerID) + } + + result, err := w.reader.db.Exec(`UPDATE Unit SET ContainerID = ? WHERE UnitID = ?`, containerIDBlob, unitIDBlob) + if err != nil { + return err + } + + rowsAffected, err := result.RowsAffected() + if err != nil { + return fmt.Errorf("failed to get rows affected: %w", err) + } + if rowsAffected == 0 { + return fmt.Errorf("unit not found: %s", unitID) + } + + w.reader.InvalidateCache() + w.updateTransactionID() + return nil +} diff --git a/modelsdk/property/base.go b/modelsdk/property/base.go new file mode 100644 index 00000000..8f801778 --- /dev/null +++ b/modelsdk/property/base.go @@ -0,0 +1,27 @@ +package property + +import "github.com/mendixlabs/mxcli/modelsdk/element" + +// propertyBase holds the common fields shared by all property types: +// name, dirty flag, owner element, and dirty-bit index. +type propertyBase struct { + name string + dirty bool + owner *element.Base + bit uint +} + +func (b *propertyBase) Name() string { return b.name } +func (b *propertyBase) Dirty() bool { return b.dirty } + +func (b *propertyBase) Bind(owner *element.Base, bit uint) { + b.owner = owner + b.bit = bit +} + +func (b *propertyBase) markDirty() { + b.dirty = true + if b.owner != nil { + b.owner.MarkDirty(b.bit) + } +} diff --git a/modelsdk/property/dirty_test.go b/modelsdk/property/dirty_test.go new file mode 100644 index 00000000..7d616385 --- /dev/null +++ b/modelsdk/property/dirty_test.go @@ -0,0 +1,78 @@ +package property + +import ( + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/element" +) + +func TestPrimitiveBindPropagates(t *testing.T) { + owner := &element.Base{} + p := NewPrimitive[string]("Name", DecodeString) + p.Bind(owner, 0) + p.Set("hello") + if !owner.IsDirty() { + t.Error("owner should be dirty") + } + bits := owner.DirtyBits() + if len(bits) < 1 || bits[0]&(1<<0) == 0 { + t.Error("bit 0 should be set") + } +} + +func TestPartBindPropagates(t *testing.T) { + owner := &element.Base{} + p := NewPart[element.Element]("Gen") + p.Bind(owner, 3) + p.Set(&element.Base{}) + if !owner.IsDirty() { + t.Error("owner should be dirty") + } +} + +func TestPartListAppendSetsContainer(t *testing.T) { + owner := &element.Base{} + pl := NewPartList[element.Element]("Attrs") + pl.Bind(owner, 5) + child := &element.Base{} + pl.Append(child) + if !owner.IsDirty() { + t.Error("owner should be dirty") + } + if child.Container() != owner { + t.Error("child container should be owner") + } +} + +func TestEnumBindPropagates(t *testing.T) { + owner := &element.Base{} + e := NewEnum[string]("Level") + e.Bind(owner, 7) + e.Set("Hidden") + bits2 := owner.DirtyBits() + if len(bits2) < 1 || bits2[0]&(1<<7) == 0 { + t.Error("bit 7 should be set") + } +} + +func TestByNameRefBindPropagates(t *testing.T) { + owner := &element.Base{} + r := NewByNameRef[element.Element]("Image", "Images$Image") + r.Bind(owner, 10) + r.SetQualifiedName("Mod.Img") + bits3 := owner.DirtyBits() + if len(bits3) < 1 || bits3[0]&(1<<10) == 0 { + t.Error("bit 10 should be set") + } +} + +func TestByIdRefBindPropagates(t *testing.T) { + owner := &element.Base{} + r := NewByIdRef[element.Element]("child") + r.Bind(owner, 2) + r.SetID("some-id") + bits4 := owner.DirtyBits() + if len(bits4) < 1 || bits4[0]&(1<<2) == 0 { + t.Error("bit 2 should be set") + } +} diff --git a/modelsdk/property/edge_test.go b/modelsdk/property/edge_test.go new file mode 100644 index 00000000..a9222901 --- /dev/null +++ b/modelsdk/property/edge_test.go @@ -0,0 +1,197 @@ +package property + +import ( + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/element" + "go.mongodb.org/mongo-driver/bson" +) + +// --- Primitive edge cases --- + +func TestPrimitiveGetBeforeInit(t *testing.T) { + p := NewPrimitive[int32]("count", DecodeInt32) + // No Init, no raw — should return zero + if got := p.Get(); got != 0 { + t.Errorf("Get() = %d, want 0", got) + } +} + +func TestPrimitiveSetOverridesLazy(t *testing.T) { + raw := mustMarshal(bson.D{{Key: "name", Value: "lazy"}}) + p := NewPrimitive[string]("name", DecodeString) + p.Init(raw) + + p.Set("eager") + if p.Get() != "eager" { + t.Errorf("Set should override lazy, got %q", p.Get()) + } +} + +func TestPrimitiveFloat64(t *testing.T) { + raw := mustMarshal(bson.D{{Key: "val", Value: 3.14}}) + p := NewPrimitive[float64]("val", DecodeFloat64) + p.Init(raw) + if got := p.Get(); got != 3.14 { + t.Errorf("Get() = %f, want 3.14", got) + } +} + +func TestPrimitiveBSONValue(t *testing.T) { + p := NewPrimitive[string]("name", DecodeString) + p.Set("test") + if p.BSONValue() != "test" { + t.Errorf("BSONValue() = %v", p.BSONValue()) + } +} + +// --- Part edge cases --- + +func TestPartSetNil(t *testing.T) { + p := NewPart[element.Element]("gen") + p.Set(nil) + if p.Get() != nil { + t.Error("Set(nil) then Get should return nil") + } + if !p.Dirty() { + t.Error("Set(nil) should still mark dirty") + } +} + +func TestPartChildElement(t *testing.T) { + p := NewPart[element.Element]("gen") + if p.ChildElement() != nil { + t.Error("unset Part.ChildElement should be nil") + } + child := &element.Base{} + p.Set(child) + if p.ChildElement() != child { + t.Error("ChildElement should return the set child") + } +} + +// --- PartList edge cases --- + +func TestPartListRemoveOutOfBoundsEdge(t *testing.T) { + pl := NewPartList[element.Element]("items") + pl.Append(&element.Base{}) + + pl.Remove(-1) + pl.Remove(999) + if pl.Len() != 1 { + t.Errorf("out-of-bounds Remove should not change Len, got %d", pl.Len()) + } +} + +func TestPartListChildElements(t *testing.T) { + pl := NewPartList[element.Element]("items") + a := &element.Base{} + b := &element.Base{} + pl.AppendFromDecode(a) + pl.AppendFromDecode(b) + + children := pl.ChildElements() + if len(children) != 2 { + t.Errorf("ChildElements len = %d, want 2", len(children)) + } + if children[0] != a || children[1] != b { + t.Error("ChildElements order wrong") + } +} + +func TestPartListAppendFromDecodeNotDirty(t *testing.T) { + pl := NewPartList[element.Element]("items") + pl.AppendFromDecode(&element.Base{}) + if pl.Dirty() { + t.Error("AppendFromDecode should not mark dirty") + } +} + +// --- ByNameRef edge cases --- + +func TestByNameRefSetFromDecodeNotDirty(t *testing.T) { + r := NewByNameRef[element.Element]("img", "Images$Image") + r.SetFromDecode("Mod.Img") + if r.Dirty() { + t.Error("SetFromDecode should not mark dirty") + } + if r.QualifiedName() != "Mod.Img" { + t.Errorf("QualifiedName = %q", r.QualifiedName()) + } +} + +func TestByNameRefBSONValue(t *testing.T) { + r := NewByNameRef[element.Element]("img", "Images$Image") + r.SetQualifiedName("Mod.Img") + if r.BSONValue() != "Mod.Img" { + t.Errorf("BSONValue = %v", r.BSONValue()) + } +} + +// --- ByNameRefList edge cases --- + +func TestByNameRefListAppend(t *testing.T) { + r := NewByNameRefList[element.Element]("roles", "Security$ModuleRole") + r.Append("Admin") + r.Append("User") + if len(r.QualifiedNames()) != 2 { + t.Errorf("len = %d", len(r.QualifiedNames())) + } + if !r.Dirty() { + t.Error("should be dirty after Append") + } +} + +// --- ByIdRef edge cases --- + +func TestByIdRefSetFromDecodeNotDirty(t *testing.T) { + r := NewByIdRef[element.Element]("child") + r.SetFromDecode("id-123") + if r.Dirty() { + t.Error("SetFromDecode should not mark dirty") + } +} + +// --- Enum edge cases --- + +func TestEnumSetFromDecodeNotDirty(t *testing.T) { + e := NewEnum[string]("level") + e.SetFromDecode("Hidden") + if e.Dirty() { + t.Error("SetFromDecode should not mark dirty") + } + if e.Get() != "Hidden" { + t.Errorf("Get = %q", e.Get()) + } +} + +func TestEnumBSONValue(t *testing.T) { + e := NewEnum[string]("level") + e.Set("API") + if e.BSONValue() != "API" { + t.Errorf("BSONValue = %v", e.BSONValue()) + } +} + +// --- EnumList --- + +func TestEnumListAppend(t *testing.T) { + el := NewEnumList[string]("tags") + el.Append("A") + el.Append("B") + if len(el.Items()) != 2 { + t.Errorf("Items len = %d", len(el.Items())) + } + if !el.Dirty() { + t.Error("should be dirty") + } +} + +func TestEnumListBSONValue(t *testing.T) { + el := NewEnumList[string]("tags") + el.Append("X") + bv := el.BSONValue().([]string) + if len(bv) != 1 || bv[0] != "X" { + t.Errorf("BSONValue = %v", bv) + } +} diff --git a/modelsdk/property/enum.go b/modelsdk/property/enum.go new file mode 100644 index 00000000..856b184a --- /dev/null +++ b/modelsdk/property/enum.go @@ -0,0 +1,55 @@ +package property + +// Enum is a property that holds a single enumeration value (a constrained string type). +type Enum[T ~string] struct { + propertyBase + val T +} + +func NewEnum[T ~string](name string) *Enum[T] { + return &Enum[T]{propertyBase: propertyBase{name: name}} +} + +func (e *Enum[T]) Get() T { return e.val } +func (e *Enum[T]) BSONValue() any { return string(e.val) } + +// Set stores the value and marks the property dirty. +func (e *Enum[T]) Set(v T) { + e.val = v + e.markDirty() +} + +// SetFromDecode populates the value during BSON decode without marking dirty. +func (e *Enum[T]) SetFromDecode(v T) { + e.val = v +} + +// EnumList is a property that holds an ordered list of enumeration values. +type EnumList[T ~string] struct { + propertyBase + items []T +} + +func NewEnumList[T ~string](name string) *EnumList[T] { + return &EnumList[T]{propertyBase: propertyBase{name: name}} +} + +func (e *EnumList[T]) Items() []T { return e.items } +func (e *EnumList[T]) BSONValue() any { + out := make([]string, len(e.items)) + for i, v := range e.items { + out[i] = string(v) + } + return out +} + +// Append adds a value to the list and marks the property dirty. +func (e *EnumList[T]) Append(v T) { + e.items = append(e.items, v) + e.markDirty() +} + +// SetFromDecode replaces the list during BSON decode without marking dirty. +func (e *EnumList[T]) SetFromDecode(items []T) { + e.items = items +} diff --git a/modelsdk/property/part.go b/modelsdk/property/part.go new file mode 100644 index 00000000..078ef87c --- /dev/null +++ b/modelsdk/property/part.go @@ -0,0 +1,110 @@ +package property + +import "github.com/mendixlabs/mxcli/modelsdk/element" + +// Part[T] holds a single contained child element. +type Part[T element.Element] struct { + propertyBase + val T + set bool +} + +func NewPart[T element.Element](name string) *Part[T] { + return &Part[T]{propertyBase: propertyBase{name: name}} +} + +func (p *Part[T]) Get() T { + if !p.set { + var zero T + return zero + } + return p.val +} + +func (p *Part[T]) Set(v T) { + p.val = v + p.set = true + p.markDirty() +} + +// BSONValue returns nil — Part children must be encoded recursively by the Encoder. +// The Encoder checks for ChildProperty interface instead. +func (p *Part[T]) BSONValue() any { return nil } + +// ChildElement returns the contained element for recursive encoding. +func (p *Part[T]) ChildElement() element.Element { + if !p.set { + return nil + } + return p.val +} + +func (p *Part[T]) SetFromDecode(v T) { + p.val = v + p.set = true + if setter, ok := any(v).(interface{ SetContainer(element.Element) }); ok && p.owner != nil { + setter.SetContainer(p.owner) + } +} + +// PartList[T] holds a list of contained child elements. +type PartList[T element.Element] struct { + propertyBase + items []T +} + +func NewPartList[T element.Element](name string) *PartList[T] { + return &PartList[T]{propertyBase: propertyBase{name: name}} +} + +func (p *PartList[T]) Items() []T { return p.items } +func (p *PartList[T]) Len() int { return len(p.items) } +func (p *PartList[T]) BSONValue() any { return nil } // handled by ChildElements + +// ChildElements returns all contained elements for recursive encoding. +func (p *PartList[T]) ChildElements() []element.Element { + out := make([]element.Element, len(p.items)) + for i, v := range p.items { + out[i] = v + } + return out +} + +func (p *PartList[T]) Append(v T) { + p.items = append(p.items, v) + p.markDirty() + if setter, ok := any(v).(interface{ SetContainer(element.Element) }); ok && p.owner != nil { + setter.SetContainer(p.owner) + } +} + +func (p *PartList[T]) Remove(index int) { + if index < 0 || index >= len(p.items) { + return + } + p.items = append(p.items[:index], p.items[index+1:]...) + p.markDirty() +} + +// InsertAt inserts an element at the given index, shifting subsequent items right. +// If index <= 0 the item is prepended; if index >= len it is appended. +func (p *PartList[T]) InsertAt(index int, v T) { + if index <= 0 { + p.items = append([]T{v}, p.items...) + } else if index >= len(p.items) { + p.items = append(p.items, v) + } else { + p.items = append(p.items[:index], append([]T{v}, p.items[index:]...)...) + } + p.markDirty() + if setter, ok := any(v).(interface{ SetContainer(element.Element) }); ok && p.owner != nil { + setter.SetContainer(p.owner) + } +} + +func (p *PartList[T]) AppendFromDecode(v T) { + p.items = append(p.items, v) + if setter, ok := any(v).(interface{ SetContainer(element.Element) }); ok && p.owner != nil { + setter.SetContainer(p.owner) + } +} diff --git a/modelsdk/property/part_test.go b/modelsdk/property/part_test.go new file mode 100644 index 00000000..c5bf09cb --- /dev/null +++ b/modelsdk/property/part_test.go @@ -0,0 +1,109 @@ +package property + +import ( + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/element" +) + +type testElement struct { + element.Base +} + +func TestPart(t *testing.T) { + p := NewPart[*testElement]("child") + + if got := p.Get(); got != nil { + t.Errorf("expected nil before Set(), got %v", got) + } + if p.Dirty() { + t.Error("expected Dirty() == false before Set()") + } + + child := &testElement{} + p.Set(child) + + if got := p.Get(); got != child { + t.Errorf("expected stored child after Set(), got %v", got) + } + if !p.Dirty() { + t.Error("expected Dirty() == true after Set()") + } +} + +func TestPartSetFromDecode(t *testing.T) { + p := NewPart[*testElement]("child") + + child := &testElement{} + p.SetFromDecode(child) + + if got := p.Get(); got != child { + t.Errorf("expected stored child after SetFromDecode(), got %v", got) + } + if p.Dirty() { + t.Error("expected Dirty() == false after SetFromDecode()") + } +} + +func TestPartList(t *testing.T) { + pl := NewPartList[*testElement]("children") + + if pl.Len() != 0 { + t.Errorf("expected Len() == 0 initially, got %d", pl.Len()) + } + if pl.Dirty() { + t.Error("expected Dirty() == false initially") + } + + a := &testElement{} + b := &testElement{} + pl.Append(a) + pl.Append(b) + + if pl.Len() != 2 { + t.Errorf("expected Len() == 2 after two Append calls, got %d", pl.Len()) + } + if !pl.Dirty() { + t.Error("expected Dirty() == true after Append()") + } + + items := pl.Items() + if items[0] != a { + t.Errorf("expected items[0] == a, got %v", items[0]) + } + if items[1] != b { + t.Errorf("expected items[1] == b, got %v", items[1]) + } + + pl.Remove(0) + + if pl.Len() != 1 { + t.Errorf("expected Len() == 1 after Remove(0), got %d", pl.Len()) + } + if pl.Items()[0] != b { + t.Errorf("expected remaining item to be b, got %v", pl.Items()[0]) + } +} + +func TestPartListRemoveOutOfBounds(t *testing.T) { + pl := NewPartList[*testElement]("children") + pl.Remove(0) // should be a no-op, not panic + pl.Remove(-1) // should be a no-op, not panic + + if pl.Dirty() { + t.Error("expected Dirty() == false after no-op Remove calls") + } +} + +func TestPartListAppendFromDecode(t *testing.T) { + pl := NewPartList[*testElement]("children") + child := &testElement{} + pl.AppendFromDecode(child) + + if pl.Len() != 1 { + t.Errorf("expected Len() == 1 after AppendFromDecode(), got %d", pl.Len()) + } + if pl.Dirty() { + t.Error("expected Dirty() == false after AppendFromDecode()") + } +} diff --git a/modelsdk/property/primitive.go b/modelsdk/property/primitive.go new file mode 100644 index 00000000..837ff2a2 --- /dev/null +++ b/modelsdk/property/primitive.go @@ -0,0 +1,80 @@ +package property + +import ( + "go.mongodb.org/mongo-driver/bson" +) + +// DecodeFunc extracts a value of type T from bson.Raw by key name. +type DecodeFunc[T any] func(raw bson.Raw, key string) T + +// Primitive[T] is a lazy-decoded scalar property. +type Primitive[T any] struct { + propertyBase + decode DecodeFunc[T] + raw bson.Raw + val T + loaded bool +} + +func NewPrimitive[T any](name string, decode DecodeFunc[T]) *Primitive[T] { + return &Primitive[T]{propertyBase: propertyBase{name: name}, decode: decode} +} + +func (p *Primitive[T]) Init(raw bson.Raw) { p.raw = raw } + +func (p *Primitive[T]) Get() T { + if !p.loaded { + if p.raw != nil { + p.val = p.decode(p.raw, p.name) + } + p.loaded = true + } + return p.val +} + +func (p *Primitive[T]) Set(v T) { + p.val = v + p.loaded = true + p.markDirty() +} + +// BSONValue returns the current value for BSON serialization. +func (p *Primitive[T]) BSONValue() any { return p.Get() } + +// --- Decode functions for common types --- + +func DecodeString(raw bson.Raw, key string) string { + val, err := raw.LookupErr(key) + if err != nil { + return "" + } + s, _ := val.StringValueOK() + return s +} + +func DecodeBool(raw bson.Raw, key string) bool { + val, err := raw.LookupErr(key) + if err != nil { + return false + } + b, _ := val.BooleanOK() + return b +} + +func DecodeInt32(raw bson.Raw, key string) int32 { + val, err := raw.LookupErr(key) + if err != nil { + return 0 + } + i, _ := val.Int32OK() + return i +} + +func DecodeFloat64(raw bson.Raw, key string) float64 { + val, err := raw.LookupErr(key) + if err != nil { + return 0 + } + f, _ := val.DoubleOK() + return f +} diff --git a/modelsdk/property/primitive_test.go b/modelsdk/property/primitive_test.go new file mode 100644 index 00000000..fb75b389 --- /dev/null +++ b/modelsdk/property/primitive_test.go @@ -0,0 +1,72 @@ +package property + +import ( + "testing" + + "go.mongodb.org/mongo-driver/bson" +) + +func mustMarshal(d bson.D) bson.Raw { + b, err := bson.Marshal(d) + if err != nil { + panic(err) + } + return bson.Raw(b) +} + +func TestPrimitiveString(t *testing.T) { + raw := mustMarshal(bson.D{{Key: "name", Value: "Customer"}}) + + p := NewPrimitive[string]("name", DecodeString) + p.Init(raw) + + if got := p.Get(); got != "Customer" { + t.Errorf("expected 'Customer', got %q", got) + } + if p.Dirty() { + t.Error("expected Dirty() == false before Set()") + } + + p.Set("Order") + + if got := p.Get(); got != "Order" { + t.Errorf("expected 'Order' after Set(), got %q", got) + } + if !p.Dirty() { + t.Error("expected Dirty() == true after Set()") + } +} + +func TestPrimitiveBool(t *testing.T) { + raw := mustMarshal(bson.D{{Key: "excluded", Value: true}}) + + p := NewPrimitive[bool]("excluded", DecodeBool) + p.Init(raw) + + if got := p.Get(); !got { + t.Errorf("expected true, got %v", got) + } +} + +func TestPrimitiveInt32(t *testing.T) { + raw := mustMarshal(bson.D{{Key: "length", Value: int32(200)}}) + + p := NewPrimitive[int32]("length", DecodeInt32) + p.Init(raw) + + if got := p.Get(); got != 200 { + t.Errorf("expected 200, got %d", got) + } +} + +func TestPrimitiveDefault(t *testing.T) { + p := NewPrimitive[string]("name", DecodeString) + // no Init call — raw remains nil + + if got := p.Get(); got != "" { + t.Errorf("expected empty string, got %q", got) + } + if p.Dirty() { + t.Error("expected Dirty() == false when no raw and no Set()") + } +} diff --git a/modelsdk/property/property_bench_test.go b/modelsdk/property/property_bench_test.go new file mode 100644 index 00000000..2756ba86 --- /dev/null +++ b/modelsdk/property/property_bench_test.go @@ -0,0 +1,44 @@ +package property + +import ( + "testing" + + "go.mongodb.org/mongo-driver/bson" +) + +func BenchmarkPrimitiveLazyDecode(b *testing.B) { + raw := mustMarshal(bson.D{ + {Key: "name", Value: "BenchmarkEntity"}, + {Key: "doc", Value: "some documentation text"}, + {Key: "count", Value: int32(42)}, + {Key: "flag", Value: true}, + }) + + b.ResetTimer() + for i := 0; i < b.N; i++ { + p := NewPrimitive[string]("name", DecodeString) + p.Init(raw) + _ = p.Get() // lazy decode + } +} + +func BenchmarkPrimitiveSetGet(b *testing.B) { + p := NewPrimitive[string]("name", DecodeString) + b.ResetTimer() + for i := 0; i < b.N; i++ { + p.Set("value") + _ = p.Get() + } +} + +func BenchmarkPrimitiveCachedGet(b *testing.B) { + raw := mustMarshal(bson.D{{Key: "name", Value: "cached"}}) + p := NewPrimitive[string]("name", DecodeString) + p.Init(raw) + _ = p.Get() // warm cache + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = p.Get() // cached read + } +} diff --git a/modelsdk/property/reference.go b/modelsdk/property/reference.go new file mode 100644 index 00000000..e74fed77 --- /dev/null +++ b/modelsdk/property/reference.go @@ -0,0 +1,96 @@ +package property + +import "github.com/mendixlabs/mxcli/modelsdk/element" + +// ByNameRef is a property that references another element by qualified name. +type ByNameRef[T element.Element] struct { + propertyBase + targetType string + qname string +} + +func NewByNameRef[T element.Element](name, targetType string) *ByNameRef[T] { + return &ByNameRef[T]{propertyBase: propertyBase{name: name}, targetType: targetType} +} + +func (r *ByNameRef[T]) TargetType() string { return r.targetType } +func (r *ByNameRef[T]) QualifiedName() string { return r.qname } +func (r *ByNameRef[T]) BSONValue() any { return r.qname } + +// SetQualifiedName sets the reference and marks the property dirty. +func (r *ByNameRef[T]) SetQualifiedName(qn string) { + r.qname = qn + r.markDirty() +} + +// SetFromDecode populates the value during BSON decode without marking dirty. +func (r *ByNameRef[T]) SetFromDecode(qn string) { + r.qname = qn +} + +// ByNameRefList is a property that holds a list of qualified-name references. +type ByNameRefList[T element.Element] struct { + propertyBase + targetType string + qnames []string +} + +func NewByNameRefList[T element.Element](name, targetType string) *ByNameRefList[T] { + return &ByNameRefList[T]{propertyBase: propertyBase{name: name}, targetType: targetType} +} + +func (r *ByNameRefList[T]) TargetType() string { return r.targetType } +func (r *ByNameRefList[T]) QualifiedNames() []string { return r.qnames } +func (r *ByNameRefList[T]) BSONValue() any { return r.qnames } + +// Append adds a qualified name to the list and marks the property dirty. +func (r *ByNameRefList[T]) Append(qn string) { + r.qnames = append(r.qnames, qn) + r.markDirty() +} + +// Remove removes the first occurrence of qn from the list and marks dirty. +func (r *ByNameRefList[T]) Remove(qn string) { + for i, q := range r.qnames { + if q == qn { + r.qnames = append(r.qnames[:i], r.qnames[i+1:]...) + r.markDirty() + return + } + } +} + +// SetQualifiedNames replaces the entire list and marks the property dirty. +func (r *ByNameRefList[T]) SetQualifiedNames(qns []string) { + r.qnames = qns + r.markDirty() +} + +// SetFromDecode replaces the list during BSON decode without marking dirty. +func (r *ByNameRefList[T]) SetFromDecode(qnames []string) { + r.qnames = qnames +} + +// ByIdRef is a property that references another element by ID. +type ByIdRef[T element.Element] struct { + propertyBase + id element.ID +} + +func NewByIdRef[T element.Element](name string) *ByIdRef[T] { + return &ByIdRef[T]{propertyBase: propertyBase{name: name}} +} + +func (r *ByIdRef[T]) RefID() element.ID { return r.id } +func (r *ByIdRef[T]) BSONValue() any { return r.id } + +// SetID stores the referenced element's ID and marks the property dirty. +func (r *ByIdRef[T]) SetID(id element.ID) { + r.id = id + r.markDirty() +} + +// SetFromDecode populates the ID during BSON decode without marking dirty. +func (r *ByIdRef[T]) SetFromDecode(id element.ID) { + r.id = id +} diff --git a/modelsdk/property/reference_test.go b/modelsdk/property/reference_test.go new file mode 100644 index 00000000..49101327 --- /dev/null +++ b/modelsdk/property/reference_test.go @@ -0,0 +1,105 @@ +package property + +import ( + "testing" +) + +func TestByNameRef(t *testing.T) { + ref := NewByNameRef[*testElement]("superClass", "DomainModels$Entity") + + if ref.Name() != "superClass" { + t.Errorf("expected name 'superClass', got %q", ref.Name()) + } + if ref.TargetType() != "DomainModels$Entity" { + t.Errorf("expected targetType 'DomainModels$Entity', got %q", ref.TargetType()) + } + if ref.QualifiedName() != "" { + t.Errorf("expected empty qname before set, got %q", ref.QualifiedName()) + } + if ref.Dirty() { + t.Error("expected Dirty() == false before SetQualifiedName()") + } + + ref.SetQualifiedName("MyModule.Customer") + + if ref.QualifiedName() != "MyModule.Customer" { + t.Errorf("expected 'MyModule.Customer', got %q", ref.QualifiedName()) + } + if !ref.Dirty() { + t.Error("expected Dirty() == true after SetQualifiedName()") + } +} + +func TestByNameRef_SetFromDecode(t *testing.T) { + ref := NewByNameRef[*testElement]("superClass", "DomainModels$Entity") + ref.SetFromDecode("MyModule.Base") + + if ref.QualifiedName() != "MyModule.Base" { + t.Errorf("expected 'MyModule.Base', got %q", ref.QualifiedName()) + } + if ref.Dirty() { + t.Error("expected Dirty() == false after SetFromDecode()") + } +} + +func TestByIdRef(t *testing.T) { + ref := NewByIdRef[*testElement]("entityRef") + + if ref.Name() != "entityRef" { + t.Errorf("expected name 'entityRef', got %q", ref.Name()) + } + if ref.RefID() != "" { + t.Errorf("expected empty RefID before SetID, got %q", ref.RefID()) + } + if ref.Dirty() { + t.Error("expected Dirty() == false before SetID()") + } + + ref.SetID("abc-123") + + if ref.RefID() != "abc-123" { + t.Errorf("expected 'abc-123', got %q", ref.RefID()) + } + if !ref.Dirty() { + t.Error("expected Dirty() == true after SetID()") + } +} + +func TestEnum(t *testing.T) { + type Visibility string + + e := NewEnum[Visibility]("visibility") + + if e.Name() != "visibility" { + t.Errorf("expected name 'visibility', got %q", e.Name()) + } + if e.Get() != "" { + t.Errorf("expected empty value before Set, got %q", e.Get()) + } + if e.Dirty() { + t.Error("expected Dirty() == false before Set()") + } + + e.Set("Hidden") + + if e.Get() != "Hidden" { + t.Errorf("expected 'Hidden', got %q", e.Get()) + } + if !e.Dirty() { + t.Error("expected Dirty() == true after Set()") + } +} + +func TestEnum_SetFromDecode(t *testing.T) { + type Visibility string + + e := NewEnum[Visibility]("visibility") + e.SetFromDecode("Visible") + + if e.Get() != "Visible" { + t.Errorf("expected 'Visible', got %q", e.Get()) + } + if e.Dirty() { + t.Error("expected Dirty() == false after SetFromDecode()") + } +} diff --git a/modelsdk/unit_cache.go b/modelsdk/unit_cache.go new file mode 100644 index 00000000..95be6316 --- /dev/null +++ b/modelsdk/unit_cache.go @@ -0,0 +1,146 @@ +package modelsdk + +import ( + "sync" + + "github.com/mendixlabs/mxcli/modelsdk/codec" + "github.com/mendixlabs/mxcli/modelsdk/element" +) + +// UnitCache caches decoded elements and provides name-based lookup. +type UnitCache struct { + mu sync.Mutex + cache map[element.ID]element.Element + cacheGen int64 + elementGen map[element.ID]int64 + typeGen map[string]int64 + nameIndex map[string]element.ID // "type:name" → unit ID +} + +func newUnitCache() *UnitCache { + return &UnitCache{ + cache: map[element.ID]element.Element{}, + elementGen: map[element.ID]int64{}, + typeGen: map[string]int64{}, + } +} + +// Get returns a cached element by ID. +func (c *UnitCache) Get(id element.ID) (element.Element, bool) { + c.mu.Lock() + defer c.mu.Unlock() + elem, ok := c.cache[id] + return elem, ok +} + +// GetWithGen returns a cached element and its generation. +func (c *UnitCache) GetWithGen(id element.ID) (element.Element, int64, bool) { + c.mu.Lock() + defer c.mu.Unlock() + elem, ok := c.cache[id] + gen := c.elementGen[id] + return elem, gen, ok +} + +// Put stores a decoded element in the cache at the current generation. +func (c *UnitCache) Put(id element.ID, elem element.Element) { + c.mu.Lock() + defer c.mu.Unlock() + c.cache[id] = elem + c.elementGen[id] = c.cacheGen +} + +// PutWithGen stores a decoded element at a specific generation. +func (c *UnitCache) PutWithGen(id element.ID, elem element.Element, gen int64) { + c.mu.Lock() + defer c.mu.Unlock() + c.cache[id] = elem + c.elementGen[id] = gen +} + +// Delete removes an element from the cache. +func (c *UnitCache) Delete(id element.ID) { + c.mu.Lock() + defer c.mu.Unlock() + delete(c.cache, id) + delete(c.elementGen, id) +} + +// TypeGen returns the current generation for a type. +func (c *UnitCache) TypeGen(typeName string) int64 { + c.mu.Lock() + defer c.mu.Unlock() + return c.typeGen[typeName] +} + +// BumpGen increments the global cache generation and the per-type generation. +func (c *UnitCache) BumpGen(typeName string) { + c.mu.Lock() + defer c.mu.Unlock() + c.cacheGen++ + if typeName != "" { + c.typeGen[typeName]++ + } +} + +// DirtyUnits returns all cached elements that have been modified. +func (c *UnitCache) DirtyUnits() map[element.ID]element.Element { + c.mu.Lock() + defer c.mu.Unlock() + dirty := make(map[element.ID]element.Element) + for id, elem := range c.cache { + if elem.IsDirty() { + dirty[id] = elem + } + } + return dirty +} + +// RebuildNameIndex rebuilds the name → ID index from unit metadata. +func (c *UnitCache) RebuildNameIndex(units []codec.UnitInfo) { + c.mu.Lock() + defer c.mu.Unlock() + idx := make(map[string]element.ID, len(units)) + for _, u := range units { + if u.Type != "" && u.Name != "" { + idx[u.Type+":"+u.Name] = u.ID + } + } + c.nameIndex = idx +} + +// FindByName looks up a unit ID by "type:name" key. +func (c *UnitCache) FindByName(key string) (element.ID, bool) { + c.mu.Lock() + defer c.mu.Unlock() + id, ok := c.nameIndex[key] + return id, ok +} + +// AddToNameIndex adds a type:name → ID mapping. +func (c *UnitCache) AddToNameIndex(typeName, name string, id element.ID) { + c.mu.Lock() + defer c.mu.Unlock() + if typeName != "" && name != "" { + c.nameIndex[typeName+":"+name] = id + } +} + +// RemoveFromNameIndex removes a type:name mapping. +func (c *UnitCache) RemoveFromNameIndex(typeName, name string) { + c.mu.Lock() + defer c.mu.Unlock() + if typeName != "" && name != "" { + delete(c.nameIndex, typeName+":"+name) + } +} + +// TypeNameOf returns the TypeName of a cached element, or empty string if not cached. +func (c *UnitCache) TypeNameOf(id element.ID) string { + c.mu.Lock() + defer c.mu.Unlock() + if elem, ok := c.cache[id]; ok { + return elem.TypeName() + } + return "" +} diff --git a/modelsdk/version/version.go b/modelsdk/version/version.go new file mode 100644 index 00000000..55cc9e3a --- /dev/null +++ b/modelsdk/version/version.go @@ -0,0 +1,72 @@ +package version + +import ( + "strconv" + "strings" +) + +type Version struct { + Major, Minor, Patch int +} + +func Parse(s string) Version { + parts := strings.SplitN(s, ".", 4) + var v Version + if len(parts) > 0 { + v.Major, _ = strconv.Atoi(parts[0]) + } + if len(parts) > 1 { + v.Minor, _ = strconv.Atoi(parts[1]) + } + if len(parts) > 2 { + v.Patch, _ = strconv.Atoi(parts[2]) + } + return v +} + +func (a Version) Compare(b Version) int { + if a.Major != b.Major { + return cmp(a.Major, b.Major) + } + if a.Minor != b.Minor { + return cmp(a.Minor, b.Minor) + } + return cmp(a.Patch, b.Patch) +} + +func (v Version) IsZero() bool { return v.Major == 0 && v.Minor == 0 && v.Patch == 0 } + +func (v Version) String() string { + return strconv.Itoa(v.Major) + "." + strconv.Itoa(v.Minor) + "." + strconv.Itoa(v.Patch) +} + +func cmp(a, b int) int { + if a < b { + return -1 + } + if a > b { + return 1 + } + return 0 +} + +type PropertyVersionInfo struct { + Introduced string + Deleted string + Required bool + Public bool +} + +func (p PropertyVersionInfo) IsAvailableIn(v Version) bool { + if p.Deleted != "" && v.Compare(Parse(p.Deleted)) >= 0 { + return false + } + if p.Introduced != "" && v.Compare(Parse(p.Introduced)) < 0 { + return false + } + return true +} + +type TypeVersionInfo struct { + Properties map[string]PropertyVersionInfo +} diff --git a/modelsdk/version/version_test.go b/modelsdk/version/version_test.go new file mode 100644 index 00000000..a4ccc15d --- /dev/null +++ b/modelsdk/version/version_test.go @@ -0,0 +1,137 @@ +package version + +import ( + "testing" +) + +func TestParse(t *testing.T) { + tests := []struct { + input string + want Version + }{ + {"10.6.3", Version{10, 6, 3}}, + {"9.17", Version{9, 17, 0}}, + {"0.0.0", Version{0, 0, 0}}, + {"1.0.0", Version{1, 0, 0}}, + {"11.8.0", Version{11, 8, 0}}, + {"", Version{0, 0, 0}}, + } + + for _, tt := range tests { + got := Parse(tt.input) + if got != tt.want { + t.Errorf("Parse(%q) = %v, want %v", tt.input, got, tt.want) + } + } +} + +func TestVersionString(t *testing.T) { + v := Version{10, 6, 3} + if got := v.String(); got != "10.6.3" { + t.Errorf("String() = %q, want %q", got, "10.6.3") + } +} + +func TestVersionIsZero(t *testing.T) { + zero := Version{} + if !zero.IsZero() { + t.Error("zero Version should be IsZero() == true") + } + nonZero := Version{Major: 1} + if nonZero.IsZero() { + t.Error("non-zero Version should be IsZero() == false") + } +} + +func TestVersionCompare(t *testing.T) { + tests := []struct { + a, b Version + want int + }{ + // equal + {Version{10, 6, 3}, Version{10, 6, 3}, 0}, + {Version{0, 0, 0}, Version{0, 0, 0}, 0}, + // less + {Version{9, 17, 0}, Version{10, 6, 3}, -1}, + {Version{10, 5, 9}, Version{10, 6, 3}, -1}, + {Version{10, 6, 2}, Version{10, 6, 3}, -1}, + // greater + {Version{10, 6, 3}, Version{9, 17, 0}, 1}, + {Version{10, 7, 0}, Version{10, 6, 3}, 1}, + {Version{10, 6, 4}, Version{10, 6, 3}, 1}, + } + + for _, tt := range tests { + got := tt.a.Compare(tt.b) + if got != tt.want { + t.Errorf("(%v).Compare(%v) = %d, want %d", tt.a, tt.b, got, tt.want) + } + } +} + +func TestPropertyVersionInfo_IsAvailableIn(t *testing.T) { + tests := []struct { + name string + prop PropertyVersionInfo + v Version + want bool + }{ + { + name: "always available (empty strings)", + prop: PropertyVersionInfo{}, + v: Version{10, 6, 3}, + want: true, + }, + { + name: "available — version meets introduced requirement", + prop: PropertyVersionInfo{Introduced: "10.0.0"}, + v: Version{10, 6, 3}, + want: true, + }, + { + name: "not yet introduced — version is below introduced", + prop: PropertyVersionInfo{Introduced: "10.6.0"}, + v: Version{9, 24, 0}, + want: false, + }, + { + name: "after deletion — version equals deleted", + prop: PropertyVersionInfo{Introduced: "9.0.0", Deleted: "11.0.0"}, + v: Version{11, 0, 0}, + want: false, + }, + { + name: "after deletion — version is beyond deleted", + prop: PropertyVersionInfo{Deleted: "10.0.0"}, + v: Version{11, 8, 0}, + want: false, + }, + { + name: "available — version is before deletion", + prop: PropertyVersionInfo{Introduced: "9.0.0", Deleted: "11.0.0"}, + v: Version{10, 24, 0}, + want: true, + }, + { + name: "exactly at introduced boundary", + prop: PropertyVersionInfo{Introduced: "10.6.0"}, + v: Version{10, 6, 0}, + want: true, + }, + { + name: "just before introduced boundary", + prop: PropertyVersionInfo{Introduced: "10.6.0"}, + v: Version{10, 5, 9}, + want: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := tt.prop.IsAvailableIn(tt.v) + if got != tt.want { + t.Errorf("IsAvailableIn(%v) = %v, want %v", tt.v, got, tt.want) + } + }) + } +} diff --git a/modelsdk/widgets/augment.go b/modelsdk/widgets/augment.go new file mode 100644 index 00000000..58f94920 --- /dev/null +++ b/modelsdk/widgets/augment.go @@ -0,0 +1,742 @@ +// SPDX-License-Identifier: Apache-2.0 + +package widgets + +import ( + "encoding/json" + "fmt" + "sync/atomic" + + "github.com/mendixlabs/mxcli/modelsdk/widgets/mpk" +) + +// AugmentTemplate modifies a template's Type and Object in-place to match an .mpk definition. +// It adds PropertyTypes (in Type) and Properties (in Object) for keys present in .mpk but +// missing from the template, and removes those present in the template but missing from .mpk. +// Only regular properties are compared (not system properties like Label, Visibility, Editability). +func AugmentTemplate(tmpl *WidgetTemplate, def *mpk.WidgetDefinition) error { + if tmpl == nil || def == nil { + return nil + } + + // Get PropertyTypes array from Type.ObjectType.PropertyTypes + objType, ok := getMapField(tmpl.Type, "ObjectType") + if !ok { + return nil + } + propTypes, ok := getArrayField(objType, "PropertyTypes") + if !ok { + return nil + } + + // Get Properties array from Object.Properties + objProps, ok := getArrayField(tmpl.Object, "Properties") + if !ok { + return nil + } + + // Build set of existing template property keys (non-system only) + templateKeys := make(map[string]bool) + // Also build a map of XML type -> exemplar index for cloning + typeExemplars := make(map[string]int) // ValueType.Type -> index in propTypes + systemKeys := def.SystemPropertyKeys() + + for i, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + continue + } + key, _ := ptMap["PropertyKey"].(string) + if key == "" { + continue + } + // Skip system properties + if systemKeys[key] { + continue + } + templateKeys[key] = true + + // Record exemplar for this value type + vt, ok := getMapField(ptMap, "ValueType") + if ok { + vtType, _ := vt["Type"].(string) + if vtType != "" { + if _, exists := typeExemplars[vtType]; !exists { + typeExemplars[vtType] = i + } + } + } + } + + // Determine mpk property keys (regular only) + mpkKeys := def.PropertyKeys() + + // Find missing keys (in mpk but not in template) + var missing []mpk.PropertyDef + for _, p := range def.Properties { + if !templateKeys[p.Key] { + missing = append(missing, p) + } + } + + // Find stale keys (in template but not in mpk, excluding system props) + var stale []string + for key := range templateKeys { + if !mpkKeys[key] && !systemKeys[key] { + stale = append(stale, key) + } + } + + // Check if nested augmentation is needed (skip early return if so) + hasNestedChildren := false + for _, p := range def.Properties { + if len(p.Children) > 0 { + hasNestedChildren = true + break + } + } + + // Nothing to add/remove at top level, and no nested children to process + if len(missing) == 0 && len(stale) == 0 && !hasNestedChildren { + return nil + } + + // Remove stale properties + if len(stale) > 0 { + staleSet := make(map[string]bool, len(stale)) + for _, key := range stale { + staleSet[key] = true + } + propTypes, objProps = removeProperties(propTypes, objProps, staleSet) + } + + // Create a cloner for property pair deep-cloning + cloner := defaultCloner() + + // Add missing properties + for _, p := range missing { + bsonType := xmlTypeToBSONType(p.Type) + if bsonType == "" { + continue // Unknown type, skip + } + + // Find an exemplar of the same type to clone + exemplarIdx, hasExemplar := typeExemplars[bsonType] + var newPropType, newProp map[string]any + if hasExemplar { + var err error + newPropType, newProp, err = cloner.ClonePair(propTypes, objProps, exemplarIdx, p) + if err != nil { + return fmt.Errorf("augment %s: %w", tmpl.WidgetID, err) + } + } + // Fall back to createPropertyPair if cloning failed (no exemplar or no matching property) + if newPropType == nil || newProp == nil { + newPropType, newProp = createPropertyPair(p, bsonType) + } + + if newPropType != nil { + propTypes = append(propTypes, newPropType) + } + if newProp != nil { + objProps = append(objProps, newProp) + } + } + + // Write back top-level + setArrayField(objType, "PropertyTypes", propTypes) + setArrayField(tmpl.Object, "Properties", objProps) + + // Augment nested ObjectType properties (e.g., DataGrid2 column properties). + // Top-level augmentation syncs the property list, but nested ObjectTypes inside + // IsList Object properties also need syncing when the .mpk version differs + // from the template version. + for _, mpkProp := range def.Properties { + if len(mpkProp.Children) == 0 { + continue + } + if err := augmentNestedObjectType(propTypes, objProps, mpkProp); err != nil { + return fmt.Errorf("augment nested %s: %w", mpkProp.Key, err) + } + } + + return nil +} + +// augmentNestedObjectType syncs nested ObjectType PropertyTypes for an Object-type property. +// When a .mpk defines children for a property (e.g., DataGrid2 "columns" has showContentAs, +// attribute, content, header, etc.), this function ensures the template's nested ObjectType +// has the same PropertyTypes as the .mpk, adding missing ones and removing stale ones. +func augmentNestedObjectType(propTypes []any, objProps []any, mpkProp mpk.PropertyDef) error { + matchedPT, matchedPTID := findPropertyType(propTypes, mpkProp.Key) + if matchedPT == nil { + return nil + } + + ctx := resolveNestedObjectContext(matchedPT, matchedPTID, objProps) + if ctx == nil { + return nil + } + + existingKeys, nestedExemplars := buildExemplarIndex(ctx.nestedPropTypes) + missing, staleKeys := diffPropertyKeys(mpkProp.Children, existingKeys) + + if len(missing) == 0 && len(staleKeys) == 0 { + return nil + } + + nestedPropTypes := ctx.nestedPropTypes + nestedObjProps := ctx.nestedObjProps + + if len(staleKeys) > 0 { + nestedPropTypes, nestedObjProps = removeNestedProperties(nestedPropTypes, nestedObjProps, staleKeys) + } + + nestedPropTypes, nestedObjProps, err := addMissingProperties(nestedPropTypes, nestedObjProps, nestedExemplars, missing) + if err != nil { + return err + } + + // Write back + setArrayField(ctx.nestedObjType, "PropertyTypes", nestedPropTypes) + for i, container := range ctx.objPropContainers { + if i < len(nestedObjProps) { + setArrayField(container, "Properties", nestedObjProps[i]) + } + } + return nil +} + +// addMissingProperties clones or creates PropertyTypes and Properties for missing keys. +func addMissingProperties(nestedPropTypes []any, nestedObjProps [][]any, exemplars map[string]int, missing []mpk.PropertyDef) ([]any, [][]any, error) { + cloner := defaultCloner() + for _, child := range missing { + bsonType := xmlTypeToBSONType(child.Type) + if bsonType == "" { + continue + } + + exemplarIdx, hasExemplar := exemplars[bsonType] + var newPropType, newProp map[string]any + if hasExemplar && len(nestedObjProps) > 0 { + var err error + newPropType, newProp, err = cloner.ClonePair(nestedPropTypes, nestedObjProps[0], exemplarIdx, child) + if err != nil { + return nil, nil, fmt.Errorf("clone nested property %q: %w", child.Key, err) + } + } + if newPropType == nil || newProp == nil { + newPropType, newProp = createPropertyPair(child, bsonType) + } + + if newPropType != nil { + nestedPropTypes = append(nestedPropTypes, newPropType) + } + if newProp != nil { + for i := range nestedObjProps { + nestedObjProps[i] = append(nestedObjProps[i], newProp) + } + } + } + return nestedPropTypes, nestedObjProps, nil +} + +// removeProperties removes PropertyTypes and their corresponding Properties by PropertyKey. +func removeProperties(propTypes []any, objProps []any, staleKeys map[string]bool) ([]any, []any) { + // Collect IDs of PropertyTypes to remove + removeIDs := make(map[string]bool) + var newPropTypes []any + for _, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + newPropTypes = append(newPropTypes, pt) // Keep markers (e.g., float64(2)) + continue + } + key, _ := ptMap["PropertyKey"].(string) + if staleKeys[key] { + id, _ := ptMap["$ID"].(string) + if id != "" { + removeIDs[id] = true + } + continue // Skip this PropertyType + } + newPropTypes = append(newPropTypes, pt) + } + + // Remove corresponding Properties whose TypePointer matches a removed PropertyType + var newObjProps []any + for _, prop := range objProps { + propMap, ok := prop.(map[string]any) + if !ok { + newObjProps = append(newObjProps, prop) // Keep markers + continue + } + tp, _ := propMap["TypePointer"].(string) + if removeIDs[tp] { + continue // Remove this property + } + newObjProps = append(newObjProps, prop) + } + + return newPropTypes, newObjProps +} + +// defaultCloner returns a PropertyCloner using the package-level placeholderID generator. +func defaultCloner() *PropertyCloner { + return NewPropertyCloner(placeholderID) +} + +// createPropertyPair creates a new PropertyType/Property pair from scratch. +func createPropertyPair(p mpk.PropertyDef, bsonType string) (map[string]any, map[string]any) { + ptID := placeholderID() + vtID := placeholderID() + + // Create PropertyType + pt := map[string]any{ + "$ID": ptID, + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": p.Caption, + "Category": p.Category, + "Description": p.Description, + "IsDefault": false, + "PropertyKey": p.Key, + "ValueType": createDefaultValueType(vtID, bsonType, p), + } + + // Create Property (WidgetProperty with WidgetValue) + prop := map[string]any{ + "$ID": placeholderID(), + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": ptID, + "Value": createDefaultWidgetValue(vtID, bsonType, p), + } + + return pt, prop +} + +// createDefaultValueType creates a default ValueType structure for a given BSON type. +func createDefaultValueType(vtID string, bsonType string, p mpk.PropertyDef) map[string]any { + vt := map[string]any{ + "$ID": vtID, + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": []any{float64(2)}, + "AllowNonPersistableEntities": false, + "AllowedTypes": []any{float64(1)}, + "AssociationTypes": []any{float64(1)}, + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": p.DefaultValue, + "EntityProperty": "", + "EnumerationValues": []any{float64(2)}, + "IsLinked": false, + "IsList": p.IsList, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": nil, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": p.Required, + "ReturnType": nil, + "SelectableObjectsProperty": "", + "SelectionTypes": []any{float64(1)}, + "SetLabel": false, + "Translations": []any{float64(2)}, + "Type": bsonType, + } + + if p.DataSource != "" { + vt["DataSourceProperty"] = p.DataSource + } + + // Build nested ObjectType for object-type properties with children + if bsonType == "Object" && len(p.Children) > 0 { + vt["ObjectType"] = buildNestedObjectType(p.Children) + } + + return vt +} + +// createDefaultWidgetValue creates a default WidgetValue for a given BSON type. +func createDefaultWidgetValue(vtID string, bsonType string, p mpk.PropertyDef) map[string]any { + val := map[string]any{ + "$ID": placeholderID(), + "$Type": "CustomWidgets$WidgetValue", + "Action": createDefaultNoAction(), + "AttributeRef": nil, + "DataSource": nil, + "EntityRef": nil, + "Expression": "", + "Form": "", + "Icon": nil, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": []any{float64(2)}, + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": nil, + "TextTemplate": nil, + "TranslatableValue": nil, + "TypePointer": vtID, + "Widgets": []any{float64(2)}, + "XPathConstraint": "", + } + + // Set type-specific defaults + switch bsonType { + case "Boolean": + if p.DefaultValue != "" { + val["PrimitiveValue"] = p.DefaultValue + } else { + val["PrimitiveValue"] = "false" + } + case "Integer": + if p.DefaultValue != "" { + val["PrimitiveValue"] = p.DefaultValue + } else { + val["PrimitiveValue"] = "0" + } + case "Enumeration": + if p.DefaultValue != "" { + val["PrimitiveValue"] = p.DefaultValue + } + case "TextTemplate": + val["TextTemplate"] = createDefaultClientTemplate() + } + + return val +} + +// createDefaultNoAction creates a default Forms$NoAction structure. +func createDefaultNoAction() map[string]any { + return map[string]any{ + "$ID": placeholderID(), + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true, + } +} + +// createDefaultClientTemplate creates a default Forms$ClientTemplate structure. +func createDefaultClientTemplate() map[string]any { + return map[string]any{ + "$ID": placeholderID(), + "$Type": "Forms$ClientTemplate", + "Fallback": map[string]any{ + "$ID": placeholderID(), + "$Type": "Texts$Text", + "Items": []any{float64(3)}, + }, + "Parameters": []any{float64(2)}, + "Template": map[string]any{ + "$ID": placeholderID(), + "$Type": "Texts$Text", + "Items": []any{float64(3)}, + }, + } +} + +// resetPropertyValue resets a WidgetValue to defaults for the given property type. +func resetPropertyValue(val map[string]any, p mpk.PropertyDef) { + bsonType := xmlTypeToBSONType(p.Type) + + // Reset all value fields to defaults + val["AttributeRef"] = nil + val["DataSource"] = nil + val["EntityRef"] = nil + val["Expression"] = "" + val["Form"] = "" + val["Icon"] = nil + val["Image"] = "" + val["Microflow"] = "" + val["Nanoflow"] = "" + val["Objects"] = []any{float64(2)} + val["PrimitiveValue"] = "" + val["Selection"] = "None" + val["SourceVariable"] = nil + val["TextTemplate"] = nil + val["TranslatableValue"] = nil + val["Widgets"] = []any{float64(2)} + val["XPathConstraint"] = "" + + // Set type-specific defaults + switch bsonType { + case "Boolean": + if p.DefaultValue != "" { + val["PrimitiveValue"] = p.DefaultValue + } else { + val["PrimitiveValue"] = "false" + } + case "Integer": + if p.DefaultValue != "" { + val["PrimitiveValue"] = p.DefaultValue + } else { + val["PrimitiveValue"] = "0" + } + case "Enumeration": + if p.DefaultValue != "" { + val["PrimitiveValue"] = p.DefaultValue + } + case "TextTemplate": + val["TextTemplate"] = createDefaultClientTemplate() + } +} + +// xmlTypeToBSONType maps XML property type to BSON ValueType.Type. +func xmlTypeToBSONType(xmlType string) string { + switch mpk.NormalizeType(xmlType) { + case "attribute": + return "Attribute" + case "expression": + return "Expression" + case "textTemplate": + return "TextTemplate" + case "widgets": + return "Widgets" + case "enumeration": + return "Enumeration" + case "boolean": + return "Boolean" + case "integer": + return "Integer" + case "datasource": + return "DataSource" + case "action": + return "Action" + case "selection": + return "Selection" + case "association": + return "Association" + case "object": + return "Object" + case "string": + return "String" + case "decimal": + return "Decimal" + case "icon": + return "Icon" + case "image": + return "Image" + case "file": + return "File" + default: + return "" + } +} + +// buildNestedObjectType creates a WidgetObjectType with PropertyTypes for nested children +// of an object-type property. This is needed for properties like filterList and sortList +// that contain sub-properties (e.g., filter, attribute, caption). +func buildNestedObjectType(children []mpk.PropertyDef) map[string]any { + propTypes := []any{float64(2)} // version marker + + for _, child := range children { + childBsonType := xmlTypeToBSONType(child.Type) + if childBsonType == "" { + continue + } + + childVTID := placeholderID() + childPT := map[string]any{ + "$ID": placeholderID(), + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": child.Caption, + "Category": "General", + "Description": child.Description, + "IsDefault": false, + "PropertyKey": child.Key, + "ValueType": createDefaultValueType(childVTID, childBsonType, child), + } + + propTypes = append(propTypes, childPT) + } + + return map[string]any{ + "$ID": placeholderID(), + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": propTypes, + } +} + +// --- Helpers --- + +// placeholderCounter generates sequential placeholder IDs (atomic for concurrent safety). +var placeholderCounter atomic.Uint32 + +// placeholderID generates a placeholder hex ID. These will be remapped by collectIDs +// in GetTemplateFullBSON, so exact values don't matter — they just need to be unique +// 32-char hex strings. +func placeholderID() string { + n := placeholderCounter.Add(1) + return fmt.Sprintf("aa000000000000000000000000%06x", n) +} + +// ResetPlaceholderCounter resets the counter (for testing). +func ResetPlaceholderCounter() { + placeholderCounter.Store(0) +} + +// getMapField gets a nested map field from a JSON map. +func getMapField(m map[string]any, key string) (map[string]any, bool) { + val, ok := m[key] + if !ok { + return nil, false + } + nested, ok := val.(map[string]any) + return nested, ok +} + +// getArrayField gets an array field from a JSON map. +func getArrayField(m map[string]any, key string) ([]any, bool) { + val, ok := m[key] + if !ok { + return nil, false + } + arr, ok := val.([]any) + return arr, ok +} + +// setArrayField sets an array field in a JSON map. +func setArrayField(m map[string]any, key string, arr []any) { + m[key] = arr +} + +// deepCloneMap deep-clones a map[string]interface{} via JSON round-trip. +func deepCloneMap(m map[string]any) (map[string]any, error) { + data, err := json.Marshal(m) + if err != nil { + return nil, fmt.Errorf("deep clone marshal: %w", err) + } + var result map[string]any + if err := json.Unmarshal(data, &result); err != nil { + return nil, fmt.Errorf("deep clone unmarshal: %w", err) + } + return result, nil +} + +// deepCloneTemplate deep-clones a WidgetTemplate so augmentation doesn't mutate the cache. +func deepCloneTemplate(tmpl *WidgetTemplate) (*WidgetTemplate, error) { + clone := &WidgetTemplate{ + WidgetID: tmpl.WidgetID, + Name: tmpl.Name, + Version: tmpl.Version, + ExtractedFrom: tmpl.ExtractedFrom, + } + + if tmpl.Type != nil { + var err error + clone.Type, err = deepCloneMap(tmpl.Type) + if err != nil { + return nil, fmt.Errorf("clone template type %s: %w", tmpl.WidgetID, err) + } + } + if tmpl.Object != nil { + var err error + clone.Object, err = deepCloneMap(tmpl.Object) + if err != nil { + return nil, fmt.Errorf("clone template object %s: %w", tmpl.WidgetID, err) + } + } + + return clone, nil +} + +// collectNestedPropertyTypeIDs extracts PropertyKey→$ID mappings from a ValueType's ObjectType. +func collectNestedPropertyTypeIDs(vt map[string]any) map[string]string { + result := make(map[string]string) + objType, ok := getMapField(vt, "ObjectType") + if !ok { + return result + } + propTypes, ok := getArrayField(objType, "PropertyTypes") + if !ok { + return result + } + for _, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + continue + } + key, _ := ptMap["PropertyKey"].(string) + id, _ := ptMap["$ID"].(string) + if key != "" && id != "" { + result[key] = id + } + } + return result +} + +// collectNestedPropertyTypeIDsByKey extracts PropertyKey→$ID from a rebuilt ObjectType map. +func collectNestedPropertyTypeIDsByKey(objType map[string]any) map[string]string { + result := make(map[string]string) + propTypes, ok := getArrayField(objType, "PropertyTypes") + if !ok { + return result + } + for _, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + continue + } + key, _ := ptMap["PropertyKey"].(string) + id, _ := ptMap["$ID"].(string) + if key != "" && id != "" { + result[key] = id + } + } + return result +} + +// remapObjectTypePointers walks the Object Properties array and updates TypePointers +// that reference old PropertyType IDs from a rebuilt ObjectType. +func remapObjectTypePointers(objProps []any, idRemap map[string]string) { + if len(idRemap) == 0 { + return + } + for _, prop := range objProps { + propMap, ok := prop.(map[string]any) + if !ok { + continue + } + // Check Value.Objects for nested WidgetObjects with TypePointers + val, ok := getMapField(propMap, "Value") + if !ok { + continue + } + objects, ok := getArrayField(val, "Objects") + if !ok { + continue + } + for _, obj := range objects { + objMap, ok := obj.(map[string]any) + if !ok { + continue + } + // Remap the object's nested properties' TypePointers + nestedProps, ok := getArrayField(objMap, "Properties") + if !ok { + continue + } + for _, nestedProp := range nestedProps { + npMap, ok := nestedProp.(map[string]any) + if !ok { + continue + } + if tp, ok := npMap["TypePointer"].(string); ok { + if newTP, exists := idRemap[tp]; exists { + npMap["TypePointer"] = newTP + } + } + // Also remap Value.TypePointer (references ValueType $ID) + if nestedVal, ok := getMapField(npMap, "Value"); ok { + if tp, ok := nestedVal["TypePointer"].(string); ok { + if newTP, exists := idRemap[tp]; exists { + nestedVal["TypePointer"] = newTP + } + } + } + } + } + } +} diff --git a/modelsdk/widgets/augment_test.go b/modelsdk/widgets/augment_test.go new file mode 100644 index 00000000..c8ff2abd --- /dev/null +++ b/modelsdk/widgets/augment_test.go @@ -0,0 +1,895 @@ +// SPDX-License-Identifier: Apache-2.0 + +package widgets + +import ( + "fmt" + "testing" + + "github.com/mendixlabs/mxcli/modelsdk/widgets/mpk" +) + +func TestAugmentTemplate_AddMissing(t *testing.T) { + ResetPlaceholderCounter() + + // Create a minimal template with one Enumeration property + tmpl := &WidgetTemplate{ + WidgetID: "test.Widget", + Type: map[string]any{ + "$ID": "type0001", + "$Type": "CustomWidgets$CustomWidgetType", + "ObjectType": map[string]any{ + "$ID": "objtype0001", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": []any{ + float64(2), + map[string]any{ + "$ID": "pt0001", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Source", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "source", + "ValueType": map[string]any{ + "$ID": "vt0001", + "$Type": "CustomWidgets$WidgetValueType", + "Type": "Enumeration", + "DefaultValue": "a", + "Required": true, + "IsList": false, + "DataSourceProperty": "", + "EnumerationValues": []any{float64(2)}, + "ObjectType": nil, + "ReturnType": nil, + "AllowNonPersistableEntities": false, + "AllowedTypes": []any{float64(1)}, + "AssociationTypes": []any{float64(1)}, + "DefaultType": "None", + "EntityProperty": "", + "IsLinked": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "SelectableObjectsProperty": "", + "SelectionTypes": []any{float64(1)}, + "SetLabel": false, + "Translations": []any{float64(2)}, + "ActionVariables": []any{float64(2)}, + }, + }, + }, + }, + }, + Object: map[string]any{ + "$ID": "obj0001", + "$Type": "CustomWidgets$WidgetObject", + "Properties": []any{ + float64(2), + map[string]any{ + "$ID": "prop0001", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "pt0001", + "Value": map[string]any{ + "$ID": "val0001", + "$Type": "CustomWidgets$WidgetValue", + "PrimitiveValue": "a", + "TypePointer": "vt0001", + "Action": map[string]any{ + "$ID": "act0001", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true, + }, + "AttributeRef": nil, + "DataSource": nil, + "EntityRef": nil, + "Expression": "", + "Form": "", + "Icon": nil, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": []any{float64(2)}, + "Selection": "None", + "SourceVariable": nil, + "TextTemplate": nil, + "TranslatableValue": nil, + "Widgets": []any{float64(2)}, + "XPathConstraint": "", + }, + }, + }, + }, + } + + // MPK definition has source + an extra boolean property + def := &mpk.WidgetDefinition{ + ID: "test.Widget", + Name: "Test Widget", + Version: "1.0.0", + Properties: []mpk.PropertyDef{ + {Key: "source", Type: "enumeration", DefaultValue: "a"}, + {Key: "clearable", Type: "boolean", Caption: "Clearable", DefaultValue: "true"}, + }, + } + + err := AugmentTemplate(tmpl, def) + if err != nil { + t.Fatalf("AugmentTemplate failed: %v", err) + } + + // Check that PropertyTypes now has 2 entries (plus the marker) + objType := tmpl.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + + propertyTypeCount := 0 + for _, pt := range propTypes { + if _, ok := pt.(map[string]any); ok { + propertyTypeCount++ + } + } + if propertyTypeCount != 2 { + t.Errorf("expected 2 PropertyTypes, got %d", propertyTypeCount) + } + + // Check that the new PropertyType has correct key + newPT := propTypes[len(propTypes)-1].(map[string]any) + if newPT["PropertyKey"] != "clearable" { + t.Errorf("expected PropertyKey 'clearable', got %v", newPT["PropertyKey"]) + } + + // Check that Object.Properties also has 2 entries + objProps := tmpl.Object["Properties"].([]any) + propertyCount := 0 + for _, p := range objProps { + if _, ok := p.(map[string]any); ok { + propertyCount++ + } + } + if propertyCount != 2 { + t.Errorf("expected 2 Properties, got %d", propertyCount) + } +} + +func TestAugmentTemplate_RemoveStale(t *testing.T) { + ResetPlaceholderCounter() + + // Template has 2 properties: source and oldProp + tmpl := &WidgetTemplate{ + WidgetID: "test.Widget", + Type: map[string]any{ + "$ID": "type0001", + "$Type": "CustomWidgets$CustomWidgetType", + "ObjectType": map[string]any{ + "$ID": "objtype0001", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": []any{ + float64(2), + map[string]any{ + "$ID": "pt0001", + "$Type": "CustomWidgets$WidgetPropertyType", + "PropertyKey": "source", + "ValueType": map[string]any{ + "$ID": "vt0001", + "$Type": "CustomWidgets$WidgetValueType", + "Type": "Enumeration", + }, + }, + map[string]any{ + "$ID": "pt0002", + "$Type": "CustomWidgets$WidgetPropertyType", + "PropertyKey": "oldProp", + "ValueType": map[string]any{ + "$ID": "vt0002", + "$Type": "CustomWidgets$WidgetValueType", + "Type": "Boolean", + }, + }, + }, + }, + }, + Object: map[string]any{ + "$ID": "obj0001", + "$Type": "CustomWidgets$WidgetObject", + "Properties": []any{ + float64(2), + map[string]any{ + "$ID": "prop0001", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "pt0001", + }, + map[string]any{ + "$ID": "prop0002", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "pt0002", + }, + }, + }, + } + + // MPK only has source (oldProp was removed) + def := &mpk.WidgetDefinition{ + ID: "test.Widget", + Properties: []mpk.PropertyDef{ + {Key: "source", Type: "enumeration"}, + }, + } + + err := AugmentTemplate(tmpl, def) + if err != nil { + t.Fatalf("AugmentTemplate failed: %v", err) + } + + // Check PropertyTypes: should have 1 entry + objType := tmpl.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + propertyTypeCount := 0 + for _, pt := range propTypes { + if ptMap, ok := pt.(map[string]any); ok { + propertyTypeCount++ + if ptMap["PropertyKey"] == "oldProp" { + t.Error("oldProp should have been removed from PropertyTypes") + } + } + } + if propertyTypeCount != 1 { + t.Errorf("expected 1 PropertyType, got %d", propertyTypeCount) + } + + // Check Properties: should have 1 entry + objProps := tmpl.Object["Properties"].([]any) + propertyCount := 0 + for _, p := range objProps { + if pMap, ok := p.(map[string]any); ok { + propertyCount++ + if pMap["TypePointer"] == "pt0002" { + t.Error("property with TypePointer pt0002 should have been removed") + } + } + } + if propertyCount != 1 { + t.Errorf("expected 1 Property, got %d", propertyCount) + } +} + +func TestAugmentTemplate_NoChange(t *testing.T) { + ResetPlaceholderCounter() + + tmpl := &WidgetTemplate{ + WidgetID: "test.Widget", + Type: map[string]any{ + "ObjectType": map[string]any{ + "PropertyTypes": []any{ + float64(2), + map[string]any{ + "$ID": "pt0001", + "PropertyKey": "source", + "ValueType": map[string]any{ + "$ID": "vt0001", + "Type": "Enumeration", + }, + }, + }, + }, + }, + Object: map[string]any{ + "Properties": []any{ + float64(2), + map[string]any{ + "TypePointer": "pt0001", + }, + }, + }, + } + + // MPK has exactly the same property + def := &mpk.WidgetDefinition{ + ID: "test.Widget", + Properties: []mpk.PropertyDef{ + {Key: "source", Type: "enumeration"}, + }, + } + + err := AugmentTemplate(tmpl, def) + if err != nil { + t.Fatalf("AugmentTemplate failed: %v", err) + } + + // Should still have exactly 1 property type + objType := tmpl.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + count := 0 + for _, pt := range propTypes { + if _, ok := pt.(map[string]any); ok { + count++ + } + } + if count != 1 { + t.Errorf("expected 1 PropertyType (no change), got %d", count) + } +} + +func TestAugmentTemplate_SystemPropsIgnored(t *testing.T) { + ResetPlaceholderCounter() + + // Template has Label system property + tmpl := &WidgetTemplate{ + WidgetID: "test.Widget", + Type: map[string]any{ + "ObjectType": map[string]any{ + "PropertyTypes": []any{ + float64(2), + map[string]any{ + "$ID": "pt0001", + "PropertyKey": "source", + "ValueType": map[string]any{"$ID": "vt0001", "Type": "Enumeration"}, + }, + map[string]any{ + "$ID": "pt0002", + "PropertyKey": "Label", + "ValueType": map[string]any{"$ID": "vt0002", "Type": "System"}, + }, + }, + }, + }, + Object: map[string]any{ + "Properties": []any{ + float64(2), + map[string]any{"TypePointer": "pt0001"}, + map[string]any{"TypePointer": "pt0002"}, + }, + }, + } + + // MPK has source + Label system prop (Label should not be removed even though + // it's only in SystemProps, not Properties) + def := &mpk.WidgetDefinition{ + ID: "test.Widget", + Properties: []mpk.PropertyDef{ + {Key: "source", Type: "enumeration"}, + }, + SystemProps: []mpk.PropertyDef{ + {Key: "Label", IsSystem: true}, + }, + } + + err := AugmentTemplate(tmpl, def) + if err != nil { + t.Fatalf("AugmentTemplate failed: %v", err) + } + + // Label should still be in PropertyTypes (system props are not touched) + objType := tmpl.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + count := 0 + for _, pt := range propTypes { + if _, ok := pt.(map[string]any); ok { + count++ + } + } + if count != 2 { + t.Errorf("expected 2 PropertyTypes (Label preserved), got %d", count) + } +} + +func TestAugmentTemplate_NilInputs(t *testing.T) { + // Should not panic + err := AugmentTemplate(nil, nil) + if err != nil { + t.Errorf("expected nil error for nil inputs, got: %v", err) + } + + err = AugmentTemplate(&WidgetTemplate{}, nil) + if err != nil { + t.Errorf("expected nil error for nil def, got: %v", err) + } +} + +func TestXmlTypeToBSONType(t *testing.T) { + tests := []struct { + xml string + bson string + }{ + {"attribute", "Attribute"}, + {"expression", "Expression"}, + {"textTemplate", "TextTemplate"}, + {"widgets", "Widgets"}, + {"enumeration", "Enumeration"}, + {"boolean", "Boolean"}, + {"integer", "Integer"}, + {"datasource", "DataSource"}, + {"action", "Action"}, + {"selection", "Selection"}, + {"association", "Association"}, + {"object", "Object"}, + {"string", "String"}, + {"decimal", "Decimal"}, + {"unknownType", ""}, + } + + for _, tt := range tests { + result := xmlTypeToBSONType(tt.xml) + if result != tt.bson { + t.Errorf("xmlTypeToBSONType(%q) = %q, want %q", tt.xml, result, tt.bson) + } + } +} + +func TestDeepCloneTemplate(t *testing.T) { + original := &WidgetTemplate{ + WidgetID: "test.Widget", + Name: "Test", + Type: map[string]any{ + "key": "value", + "nested": map[string]any{ + "inner": "data", + }, + }, + Object: map[string]any{ + "prop": "val", + }, + } + + clone, err := deepCloneTemplate(original) + if err != nil { + t.Fatalf("deepCloneTemplate failed: %v", err) + } + + // Modify clone + clone.Type["key"] = "modified" + clone.Type["nested"].(map[string]any)["inner"] = "modified" + + // Original should be unchanged + if original.Type["key"] != "value" { + t.Error("original Type was modified") + } + if original.Type["nested"].(map[string]any)["inner"] != "data" { + t.Error("original nested Type was modified") + } +} + +func TestCreatePropertyPair_TextTemplate(t *testing.T) { + ResetPlaceholderCounter() + + p := mpk.PropertyDef{ + Key: "myTextProp", + Type: "textTemplate", + Caption: "My Text", + } + + pt, prop := createPropertyPair(p, "TextTemplate") + if pt == nil { + t.Fatal("PropertyType should not be nil") + } + if prop == nil { + t.Fatal("Property should not be nil") + } + + // Check that the Value has a TextTemplate (not nil) + val := prop["Value"].(map[string]any) + tt := val["TextTemplate"] + if tt == nil { + t.Fatal("TextTemplate should not be nil for textTemplate type") + } + ttMap := tt.(map[string]any) + if ttMap["$Type"] != "Forms$ClientTemplate" { + t.Errorf("expected Forms$ClientTemplate, got %v", ttMap["$Type"]) + } +} + +func TestAugmentTemplate_WithRealTemplate(t *testing.T) { + // Load the actual combobox template and augment with a mock definition + // that adds one extra boolean property + tmpl, err := GetTemplate("com.mendix.widget.web.combobox.Combobox") + if err != nil { + t.Fatalf("GetTemplate failed: %v", err) + } + if tmpl == nil { + t.Skip("ComboBox template not available") + } + + ResetPlaceholderCounter() + clone, err := deepCloneTemplate(tmpl) + if err != nil { + t.Fatalf("deepCloneTemplate failed: %v", err) + } + + // Count original properties + objType := clone.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + originalCount := 0 + for _, pt := range propTypes { + if _, ok := pt.(map[string]any); ok { + originalCount++ + } + } + + // Create a definition that has all existing properties plus one new one + def := &mpk.WidgetDefinition{ + ID: "com.mendix.widget.web.combobox.Combobox", + Version: "3.0.0", + } + + // Copy existing properties from template + for _, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + continue + } + key, _ := ptMap["PropertyKey"].(string) + vt, _ := ptMap["ValueType"].(map[string]any) + vtType := "" + if vt != nil { + vtType, _ = vt["Type"].(string) + } + if vtType == "System" { + def.SystemProps = append(def.SystemProps, mpk.PropertyDef{Key: key, IsSystem: true}) + } else { + xmlType := bsonTypeToXmlType(vtType) + def.Properties = append(def.Properties, mpk.PropertyDef{Key: key, Type: xmlType}) + } + } + + // Add one new property + def.Properties = append(def.Properties, mpk.PropertyDef{ + Key: "newTestProperty", + Type: "boolean", + Caption: "New Test Property", + DefaultValue: "false", + }) + + err = AugmentTemplate(clone, def) + if err != nil { + t.Fatalf("AugmentTemplate failed: %v", err) + } + + // Check that we now have originalCount + 1 property types + updatedPropTypes := objType["PropertyTypes"].([]any) + newCount := 0 + for _, pt := range updatedPropTypes { + if _, ok := pt.(map[string]any); ok { + newCount++ + } + } + if newCount != originalCount+1 { + t.Errorf("expected %d PropertyTypes, got %d", originalCount+1, newCount) + } + + // Count original Object.Properties (may differ from PropertyTypes due to system props) + origObjProps := tmpl.Object["Properties"].([]any) + origPropCount := 0 + for _, p := range origObjProps { + if _, ok := p.(map[string]any); ok { + origPropCount++ + } + } + + // Check the Properties in Object also increased by 1 + objProps := clone.Object["Properties"].([]any) + propCount := 0 + for _, p := range objProps { + if _, ok := p.(map[string]any); ok { + propCount++ + } + } + if propCount != origPropCount+1 { + t.Errorf("expected %d Properties, got %d", origPropCount+1, propCount) + } +} + +// TestAugmentTemplate_NoPlaceholderLeakAfterBSONConversion verifies that after +// augmentation and BSON conversion, no placeholder IDs remain. This is the bug +// from issue #6: regenerateNestedIDs overwrote ValueType.$ID after newVTID was +// captured, causing Value.TypePointer to reference an unmapped placeholder. +func TestAugmentTemplate_NoPlaceholderLeakAfterBSONConversion(t *testing.T) { + ResetPlaceholderCounter() + + tmpl, err := GetTemplate("com.mendix.widget.web.combobox.Combobox") + if err != nil { + t.Fatalf("GetTemplate failed: %v", err) + } + if tmpl == nil { + t.Skip("ComboBox template not available") + } + + clone, err := deepCloneTemplate(tmpl) + if err != nil { + t.Fatalf("deepCloneTemplate failed: %v", err) + } + + // Build a definition with existing properties + one new one + objType := clone.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + def := &mpk.WidgetDefinition{ + ID: "com.mendix.widget.web.combobox.Combobox", + Version: "3.0.0", + } + for _, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + continue + } + key, _ := ptMap["PropertyKey"].(string) + vt, _ := ptMap["ValueType"].(map[string]any) + vtType := "" + if vt != nil { + vtType, _ = vt["Type"].(string) + } + if vtType == "System" { + def.SystemProps = append(def.SystemProps, mpk.PropertyDef{Key: key, IsSystem: true}) + } else { + xmlType := bsonTypeToXmlType(vtType) + def.Properties = append(def.Properties, mpk.PropertyDef{Key: key, Type: xmlType}) + } + } + def.Properties = append(def.Properties, mpk.PropertyDef{ + Key: "extraBoolProp", + Type: "boolean", + Caption: "Extra Bool", + DefaultValue: "false", + }) + + if err := AugmentTemplate(clone, def); err != nil { + t.Fatalf("AugmentTemplate failed: %v", err) + } + + // Now run the full BSON conversion pipeline (same as GetTemplateFullBSON) + counter := 0 + idGen := func() string { + counter++ + return fmt.Sprintf("bbbbbbbb0000000000000000%08x", counter) + } + + idMapping := make(map[string]string) + collectIDs(clone.Type, idGen, idMapping) + if clone.Object != nil { + collectIDs(clone.Object, idGen, idMapping) + } + + var objectTypeID string + propertyTypeIDs := make(map[string]PropertyTypeIDEntry) + bsonType := jsonToBSONWithMappingAndObjectType(clone.Type, idMapping, propertyTypeIDs, &objectTypeID) + bsonObject := jsonToBSONObjectWithMapping(clone.Object, idMapping) + + if containsPlaceholderID(bsonType) { + t.Error("placeholder ID leak in Type BSON after augmentation") + } + if containsPlaceholderID(bsonObject) { + t.Error("placeholder ID leak in Object BSON after augmentation — issue #6 regression") + } +} + +// bsonTypeToXmlType is a test helper to reverse the mapping. +func bsonTypeToXmlType(bsonType string) string { + switch bsonType { + case "Attribute": + return "attribute" + case "Expression": + return "expression" + case "TextTemplate": + return "textTemplate" + case "Widgets": + return "widgets" + case "Enumeration": + return "enumeration" + case "Boolean": + return "boolean" + case "Integer": + return "integer" + case "DataSource": + return "datasource" + case "Action": + return "action" + case "Selection": + return "selection" + case "Association": + return "association" + case "Object": + return "object" + case "String": + return "string" + case "Decimal": + return "decimal" + default: + return "string" + } +} + +func TestAugmentTemplate_NestedObjectType_AddMissing(t *testing.T) { + ResetPlaceholderCounter() + + // Template has an Object-type property "columns" with one nested property "header" + tmpl := &WidgetTemplate{ + WidgetID: "test.DataGrid", + Type: map[string]any{ + "$ID": "type0001", + "$Type": "CustomWidgets$CustomWidgetType", + "ObjectType": map[string]any{ + "$ID": "objtype0001", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": []any{ + float64(2), + map[string]any{ + "$ID": "pt-columns", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Columns", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "columns", + "ValueType": map[string]any{ + "$ID": "vt-columns", + "$Type": "CustomWidgets$WidgetValueType", + "Type": "Object", + "IsList": true, + "Required": false, + "ObjectType": map[string]any{ + "$ID": "nested-objtype", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": []any{ + float64(2), + map[string]any{ + "$ID": "npt-header", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Header", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "header", + "ValueType": map[string]any{ + "$ID": "nvt-header", + "$Type": "CustomWidgets$WidgetValueType", + "Type": "TextTemplate", + "DefaultValue": "", + "Required": false, + "IsList": false, + }, + }, + }, + }, + "DefaultValue": "", + "DataSourceProperty": "", + "EnumerationValues": []any{float64(2)}, + "ReturnType": nil, + "AllowNonPersistableEntities": false, + "AllowedTypes": []any{float64(1)}, + "AssociationTypes": []any{float64(1)}, + "DefaultType": "None", + "EntityProperty": "", + "IsLinked": false, + }, + }, + }, + }, + }, + Object: map[string]any{ + "$ID": "obj0001", + "$Type": "CustomWidgets$WidgetObject", + "Properties": []any{ + float64(2), + map[string]any{ + "$ID": "prop-columns", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "pt-columns", + "Value": map[string]any{ + "$ID": "val-columns", + "$Type": "CustomWidgets$WidgetValue", + "TypePointer": "vt-columns", + "Objects": []any{ + float64(2), + map[string]any{ + "$ID": "col-obj-1", + "$Type": "CustomWidgets$WidgetObject", + "TypePointer": "nested-objtype", + "Properties": []any{ + float64(2), + map[string]any{ + "$ID": "col-prop-header", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "npt-header", + "Value": map[string]any{ + "$ID": "col-val-header", + "$Type": "CustomWidgets$WidgetValue", + "TypePointer": "nvt-header", + }, + }, + }, + }, + }, + }, + }, + }, + }, + } + + // .mpk defines "columns" with two children: "header" (existing) and "tooltip" (new) + def := &mpk.WidgetDefinition{ + ID: "test.DataGrid", + Name: "DataGrid", + Properties: []mpk.PropertyDef{ + { + Key: "columns", + Type: "object", + Children: []mpk.PropertyDef{ + {Key: "header", Type: "textTemplate", Caption: "Header"}, + {Key: "tooltip", Type: "textTemplate", Caption: "Tooltip"}, + }, + }, + }, + } + + err := AugmentTemplate(tmpl, def) + if err != nil { + t.Fatalf("AugmentTemplate failed: %v", err) + } + + // Verify nested ObjectType now has 2 PropertyTypes + objType, _ := getMapField(tmpl.Type, "ObjectType") + propTypes, _ := getArrayField(objType, "PropertyTypes") + // Find the columns PropertyType + for _, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + continue + } + if ptMap["PropertyKey"] != "columns" { + continue + } + vt, _ := getMapField(ptMap, "ValueType") + nestedOT, _ := getMapField(vt, "ObjectType") + nestedPTs, _ := getArrayField(nestedOT, "PropertyTypes") + + // Count non-marker entries + count := 0 + hasTooltip := false + for _, npt := range nestedPTs { + nptMap, ok := npt.(map[string]any) + if !ok { + continue + } + count++ + if nptMap["PropertyKey"] == "tooltip" { + hasTooltip = true + } + } + if count != 2 { + t.Errorf("expected 2 nested PropertyTypes, got %d", count) + } + if !hasTooltip { + t.Error("expected nested PropertyType 'tooltip' to be added") + } + } + + // Verify nested Object Properties also has the new property + objProps, _ := getArrayField(tmpl.Object, "Properties") + for _, prop := range objProps { + propMap, ok := prop.(map[string]any) + if !ok { + continue + } + if propMap["TypePointer"] != "pt-columns" { + continue + } + val, _ := getMapField(propMap, "Value") + objects, _ := getArrayField(val, "Objects") + for _, obj := range objects { + objMap, ok := obj.(map[string]any) + if !ok { + continue + } + nestedProps, _ := getArrayField(objMap, "Properties") + count := 0 + for _, np := range nestedProps { + if _, ok := np.(map[string]any); ok { + count++ + } + } + if count != 2 { + t.Errorf("expected 2 nested Object Properties, got %d", count) + } + } + } +} diff --git a/modelsdk/widgets/cloner.go b/modelsdk/widgets/cloner.go new file mode 100644 index 00000000..c8325586 --- /dev/null +++ b/modelsdk/widgets/cloner.go @@ -0,0 +1,163 @@ +// SPDX-License-Identifier: Apache-2.0 + +package widgets + +import ( + "fmt" + + "github.com/mendixlabs/mxcli/modelsdk/widgets/mpk" +) + +// PropertyCloner handles deep cloning of widget property+propertyType pairs +// with ID regeneration. +type PropertyCloner struct { + idGenerator func() string +} + +// NewPropertyCloner creates a PropertyCloner with the given ID generator. +func NewPropertyCloner(idGen func() string) *PropertyCloner { + return &PropertyCloner{idGenerator: idGen} +} + +// ClonePair deep-clones an existing PropertyType/Property pair and updates keys/IDs. +// It finds the exemplar PropertyType at exemplarIdx in propTypes, clones it, +// and finds the corresponding Property in objProps via TypePointer matching. +func (c *PropertyCloner) ClonePair(propTypes []any, objProps []any, exemplarIdx int, p mpk.PropertyDef) (map[string]any, map[string]any, error) { + exemplar, ok := propTypes[exemplarIdx].(map[string]any) + if !ok { + return nil, nil, nil + } + + // Deep-clone the PropertyType + newPT, err := deepCloneMap(exemplar) + if err != nil { + return nil, nil, fmt.Errorf("clone property type %q: %w", p.Key, err) + } + newPTID := c.idGenerator() + newPT["$ID"] = newPTID + newPT["PropertyKey"] = p.Key + newPT["Caption"] = p.Caption + newPT["Description"] = p.Description + newPT["Category"] = p.Category + + // Update the ValueType ID and set defaults + var newVTID string + if vt, ok := getMapField(newPT, "ValueType"); ok { + // Regenerate nested $ID fields FIRST (EnumerationValues, ObjectType, etc.) + // so they get unique placeholders without overwriting the IDs we set below. + c.RegenerateIDs(vt) + + // Now set the top-level VT $ID -- this must happen AFTER RegenerateIDs + // because RegenerateIDs replaces ALL $ID fields including this one. + // The Property's Value.TypePointer will reference this ID, so it must match. + newVTID = c.idGenerator() + vt["$ID"] = newVTID + + // Set default value for enumeration/boolean types + if p.DefaultValue != "" { + vt["DefaultValue"] = p.DefaultValue + } + + // Update Required flag + vt["Required"] = p.Required + + // Update IsList + vt["IsList"] = p.IsList + + // Update DataSourceProperty + if p.DataSource != "" { + vt["DataSourceProperty"] = p.DataSource + } else { + vt["DataSourceProperty"] = "" + } + + // Clear enumeration values for non-enumeration types or set empty + vtType, _ := vt["Type"].(string) + if vtType != "Enumeration" { + vt["EnumerationValues"] = []any{float64(2)} + } + + // Clear ObjectType for non-object types; build nested ObjectType for object types with children + if vtType != "Object" { + vt["ObjectType"] = nil + } else if len(p.Children) > 0 { + vt["ObjectType"] = buildNestedObjectType(p.Children) + } + + // Clear ReturnType for non-expression types + if vtType != "Expression" { + vt["ReturnType"] = nil + } + } + + // Find the corresponding Property in objProps that uses the exemplar's TypePointer + exemplarID, _ := exemplar["$ID"].(string) + var exemplarProp map[string]any + for _, prop := range objProps { + propMap, ok := prop.(map[string]any) + if !ok { + continue + } + tp, _ := propMap["TypePointer"].(string) + if tp == exemplarID { + exemplarProp = propMap + break + } + } + + if exemplarProp == nil { + return newPT, nil, nil + } + + // Deep-clone the Property + newProp, err := deepCloneMap(exemplarProp) + if err != nil { + return nil, nil, fmt.Errorf("clone property %q: %w", p.Key, err) + } + newProp["$ID"] = c.idGenerator() + newProp["TypePointer"] = newPTID + + // Update Value.TypePointer to reference the new ValueType ID + if val, ok := getMapField(newProp, "Value"); ok { + val["$ID"] = c.idGenerator() + if newVTID != "" { + val["TypePointer"] = newVTID + } + + // Reset the value to default for the type + resetPropertyValue(val, p) + + // Regenerate action ID + if action, ok := getMapField(val, "Action"); ok { + action["$ID"] = c.idGenerator() + } + + // Regenerate TextTemplate IDs if present + if tt, ok := getMapField(val, "TextTemplate"); ok { + c.RegenerateIDs(tt) + } + } + + return newPT, newProp, nil +} + +// RegenerateIDs walks a structure and replaces all $ID fields with new IDs +// from the cloner's ID generator. +func (c *PropertyCloner) RegenerateIDs(m map[string]any) { + for key, val := range m { + if key == "$ID" { + m[key] = c.idGenerator() + continue + } + switch v := val.(type) { + case map[string]any: + c.RegenerateIDs(v) + case []any: + for _, item := range v { + if nested, ok := item.(map[string]any); ok { + c.RegenerateIDs(nested) + } + } + } + } +} diff --git a/modelsdk/widgets/definitions/barcodescanner.def.json b/modelsdk/widgets/definitions/barcodescanner.def.json new file mode 100644 index 00000000..f521a3ae --- /dev/null +++ b/modelsdk/widgets/definitions/barcodescanner.def.json @@ -0,0 +1,9 @@ +{ + "widgetId": "com.mendix.widget.web.barcodescanner.BarcodeScanner", + "mdlName": "BARCODESCANNER", + "templateFile": "barcodescanner.json", + "defaultEditable": "Always", + "propertyMappings": [ + {"propertyKey": "datasource", "source": "Attribute", "operation": "attribute"} + ] +} diff --git a/modelsdk/widgets/definitions/combobox.def.json b/modelsdk/widgets/definitions/combobox.def.json new file mode 100644 index 00000000..21755ca5 --- /dev/null +++ b/modelsdk/widgets/definitions/combobox.def.json @@ -0,0 +1,26 @@ +{ + "widgetId": "com.mendix.widget.web.combobox.Combobox", + "mdlName": "COMBOBOX", + "templateFile": "combobox.json", + "defaultEditable": "Always", + "modes": [ + { + "name": "association", + "condition": "hasDataSource", + "description": "Association mode", + "propertyMappings": [ + {"propertyKey": "optionsSourceType", "value": "association", "operation": "primitive"}, + {"propertyKey": "optionsSourceAssociationDataSource", "source": "DataSource", "operation": "datasource"}, + {"propertyKey": "attributeAssociation", "source": "Association", "operation": "association"}, + {"propertyKey": "optionsSourceAssociationCaptionAttribute", "source": "CaptionAttribute", "operation": "attribute"} + ] + }, + { + "name": "default", + "description": "Enumeration mode", + "propertyMappings": [ + {"propertyKey": "attributeEnumeration", "source": "Attribute", "operation": "attribute"} + ] + } + ] +} diff --git a/modelsdk/widgets/definitions/datefilter.def.json b/modelsdk/widgets/definitions/datefilter.def.json new file mode 100644 index 00000000..e335dbee --- /dev/null +++ b/modelsdk/widgets/definitions/datefilter.def.json @@ -0,0 +1,11 @@ +{ + "widgetId": "com.mendix.widget.web.datagriddatefilter.DatagridDateFilter", + "mdlName": "DATEFILTER", + "templateFile": "datagrid-date-filter.json", + "defaultEditable": "Always", + "propertyMappings": [ + {"propertyKey": "attrChoice", "value": "linked", "operation": "primitive"}, + {"propertyKey": "attributes", "source": "Attributes", "operation": "attributeObjects"}, + {"propertyKey": "defaultFilter", "source": "FilterType", "operation": "primitive"} + ] +} diff --git a/modelsdk/widgets/definitions/dropdownfilter.def.json b/modelsdk/widgets/definitions/dropdownfilter.def.json new file mode 100644 index 00000000..3640df46 --- /dev/null +++ b/modelsdk/widgets/definitions/dropdownfilter.def.json @@ -0,0 +1,11 @@ +{ + "widgetId": "com.mendix.widget.web.datagriddropdownfilter.DatagridDropdownFilter", + "mdlName": "DROPDOWNFILTER", + "templateFile": "datagrid-dropdown-filter.json", + "defaultEditable": "Always", + "propertyMappings": [ + {"propertyKey": "attrChoice", "value": "custom", "operation": "primitive"}, + {"propertyKey": "attributes", "source": "Attributes", "operation": "attributeObjects"}, + {"propertyKey": "defaultFilter", "source": "FilterType", "operation": "primitive"} + ] +} diff --git a/modelsdk/widgets/definitions/dropdownsort.def.json b/modelsdk/widgets/definitions/dropdownsort.def.json new file mode 100644 index 00000000..283bc8c5 --- /dev/null +++ b/modelsdk/widgets/definitions/dropdownsort.def.json @@ -0,0 +1,6 @@ +{ + "widgetId": "com.mendix.widget.web.dropdownsort.DropdownSort", + "mdlName": "DROPDOWNSORT", + "templateFile": "dropdownsort.json", + "defaultEditable": "Always" +} diff --git a/modelsdk/widgets/definitions/gallery.def.json b/modelsdk/widgets/definitions/gallery.def.json new file mode 100644 index 00000000..27d54020 --- /dev/null +++ b/modelsdk/widgets/definitions/gallery.def.json @@ -0,0 +1,89 @@ +{ + "widgetId": "com.mendix.widget.web.gallery.Gallery", + "mdlName": "GALLERY", + "templateFile": "gallery.json", + "defaultEditable": "Always", + "propertyMappings": [ + { + "propertyKey": "advanced", + "value": "false", + "operation": "primitive" + }, + { + "propertyKey": "datasource", + "source": "DataSource", + "operation": "datasource" + }, + { + "propertyKey": "itemSelection", + "source": "Selection", + "operation": "selection", + "default": "Single" + }, + { + "propertyKey": "itemSelectionMode", + "value": "clear", + "operation": "primitive" + }, + { + "propertyKey": "desktopItems", + "source": "DesktopColumns", + "default": "1", + "operation": "primitive" + }, + { + "propertyKey": "tabletItems", + "source": "TabletColumns", + "default": "1", + "operation": "primitive" + }, + { + "propertyKey": "phoneItems", + "source": "PhoneColumns", + "default": "1", + "operation": "primitive" + }, + { + "propertyKey": "pageSize", + "value": "20", + "operation": "primitive" + }, + { + "propertyKey": "pagination", + "value": "buttons", + "operation": "primitive" + }, + { + "propertyKey": "pagingPosition", + "value": "below", + "operation": "primitive" + }, + { + "propertyKey": "showEmptyPlaceholder", + "value": "none", + "operation": "primitive" + }, + { + "propertyKey": "onClickTrigger", + "value": "single", + "operation": "primitive" + } + ], + "childSlots": [ + { + "propertyKey": "content", + "mdlContainer": "TEMPLATE", + "operation": "widgets" + }, + { + "propertyKey": "emptyPlaceholder", + "mdlContainer": "EMPTYPLACEHOLDER", + "operation": "widgets" + }, + { + "propertyKey": "filtersPlaceholder", + "mdlContainer": "FILTER", + "operation": "widgets" + } + ] +} diff --git a/modelsdk/widgets/definitions/image.def.json b/modelsdk/widgets/definitions/image.def.json new file mode 100644 index 00000000..7aae9123 --- /dev/null +++ b/modelsdk/widgets/definitions/image.def.json @@ -0,0 +1,90 @@ +{ + "widgetId": "com.mendix.widget.web.image.Image", + "mdlName": "IMAGE", + "templateFile": "image.json", + "defaultEditable": "Always", + "propertyMappings": [ + { + "propertyKey": "datasource", + "source": "ImageType", + "default": "image", + "operation": "primitive" + }, + { + "propertyKey": "imageUrl", + "source": "ImageUrl", + "operation": "texttemplate" + }, + { + "propertyKey": "alternativeText", + "source": "AlternativeText", + "operation": "texttemplate" + }, + { + "propertyKey": "onClick", + "source": "OnClick", + "operation": "action" + }, + { + "propertyKey": "onClickType", + "source": "OnClickType", + "default": "action", + "operation": "primitive" + }, + { + "propertyKey": "widthUnit", + "source": "WidthUnit", + "default": "auto", + "operation": "primitive" + }, + { + "propertyKey": "width", + "source": "Width", + "default": "100", + "operation": "primitive" + }, + { + "propertyKey": "heightUnit", + "source": "HeightUnit", + "default": "auto", + "operation": "primitive" + }, + { + "propertyKey": "height", + "source": "Height", + "default": "100", + "operation": "primitive" + }, + { + "propertyKey": "iconSize", + "source": "IconSize", + "default": "14", + "operation": "primitive" + }, + { + "propertyKey": "displayAs", + "source": "DisplayAs", + "default": "fullImage", + "operation": "primitive" + }, + { + "propertyKey": "responsive", + "source": "Responsive", + "default": "true", + "operation": "primitive" + }, + { + "propertyKey": "isBackgroundImage", + "source": "IsBackgroundImage", + "default": "false", + "operation": "primitive" + } + ], + "childSlots": [ + { + "propertyKey": "children", + "mdlContainer": "CONTENT", + "operation": "widgets" + } + ] +} diff --git a/modelsdk/widgets/definitions/loader.go b/modelsdk/widgets/definitions/loader.go new file mode 100644 index 00000000..ad6a7162 --- /dev/null +++ b/modelsdk/widgets/definitions/loader.go @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: Apache-2.0 + +// Package definitions provides embedded widget definition files for the pluggable widget engine. +package definitions + +import "embed" + +//go:embed *.def.json +var EmbeddedFS embed.FS diff --git a/modelsdk/widgets/definitions/numberfilter.def.json b/modelsdk/widgets/definitions/numberfilter.def.json new file mode 100644 index 00000000..2b7aeb09 --- /dev/null +++ b/modelsdk/widgets/definitions/numberfilter.def.json @@ -0,0 +1,11 @@ +{ + "widgetId": "com.mendix.widget.web.datagridnumberfilter.DatagridNumberFilter", + "mdlName": "NUMBERFILTER", + "templateFile": "datagrid-number-filter.json", + "defaultEditable": "Always", + "propertyMappings": [ + {"propertyKey": "attrChoice", "value": "linked", "operation": "primitive"}, + {"propertyKey": "attributes", "source": "Attributes", "operation": "attributeObjects"}, + {"propertyKey": "defaultFilter", "source": "FilterType", "operation": "primitive"} + ] +} diff --git a/modelsdk/widgets/definitions/textfilter.def.json b/modelsdk/widgets/definitions/textfilter.def.json new file mode 100644 index 00000000..17700e0a --- /dev/null +++ b/modelsdk/widgets/definitions/textfilter.def.json @@ -0,0 +1,11 @@ +{ + "widgetId": "com.mendix.widget.web.datagridtextfilter.DatagridTextFilter", + "mdlName": "TEXTFILTER", + "templateFile": "datagrid-text-filter.json", + "defaultEditable": "Always", + "propertyMappings": [ + {"propertyKey": "attrChoice", "value": "linked", "operation": "primitive"}, + {"propertyKey": "attributes", "source": "Attributes", "operation": "attributeObjects"}, + {"propertyKey": "defaultFilter", "source": "FilterType", "operation": "primitive"} + ] +} diff --git a/modelsdk/widgets/loader.go b/modelsdk/widgets/loader.go new file mode 100644 index 00000000..e18799f6 --- /dev/null +++ b/modelsdk/widgets/loader.go @@ -0,0 +1,938 @@ +// SPDX-License-Identifier: Apache-2.0 + +// Package widgets provides embedded widget templates for pluggable widgets. +package widgets + +import ( + "bytes" + "embed" + "encoding/hex" + "encoding/json" + "fmt" + "path/filepath" + "sort" + "strings" + + "log" + "sync" + + "go.mongodb.org/mongo-driver/bson" + + "github.com/mendixlabs/mxcli/modelsdk/widgets/mpk" +) + +// placeholderBinaryPrefix is the GUID-swapped byte pattern for placeholder IDs. +// Placeholder IDs are "aa000000000000000000000000XXXXXX". After hex decode and GUID +// byte-swap in hexToIDBlob, the first 13 bytes become \x00\x00\x00\xaa followed by +// 9 zero bytes. The last 3 bytes are the counter and vary. +var placeholderBinaryPrefix = []byte{0x00, 0x00, 0x00, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} + +// placeholderStringPrefix is the ASCII prefix of a placeholder ID that leaked as a string. +const placeholderStringPrefix = "aa000000000000000000000000" + +// containsPlaceholderID recursively walks a bson.D checking for leaked placeholder IDs. +// Returns true if any placeholder ID is found as a binary blob or string value. +func containsPlaceholderID(doc bson.D) bool { + for _, elem := range doc { + if containsPlaceholderValue(elem.Value) { + return true + } + } + return false +} + +// containsPlaceholderValue checks a single BSON value for placeholder IDs. +func containsPlaceholderValue(val any) bool { + switch v := val.(type) { + case []byte: + if len(v) == 16 && bytes.HasPrefix(v, placeholderBinaryPrefix) { + return true + } + case bson.D: + return containsPlaceholderID(v) + case bson.A: + for _, item := range v { + if containsPlaceholderValue(item) { + return true + } + } + case string: + if len(v) == 32 && strings.HasPrefix(v, placeholderStringPrefix) { + return true + } + } + return false +} + +// sortedMapKeys returns map keys in a deterministic order matching Mendix BSON conventions: +// $ID first, $Type second, then remaining keys alphabetically. +func sortedMapKeys(m map[string]any) []string { + keys := make([]string, 0, len(m)) + for k := range m { + keys = append(keys, k) + } + sort.Slice(keys, func(i, j int) bool { + ki, kj := keys[i], keys[j] + // $ID always first + if ki == "$ID" { + return true + } + if kj == "$ID" { + return false + } + // $Type always second + if ki == "$Type" { + return true + } + if kj == "$Type" { + return false + } + // $ keys before non-$ keys + iDollar := strings.HasPrefix(ki, "$") + jDollar := strings.HasPrefix(kj, "$") + if iDollar != jDollar { + return iDollar + } + return strings.ToLower(ki) < strings.ToLower(kj) + }) + return keys +} + +//go:embed templates/mendix-11.6/*.json +var templateFS embed.FS + +// WidgetTemplate represents a loaded widget template. +type WidgetTemplate struct { + WidgetID string `json:"widgetId"` + Name string `json:"name"` + Version string `json:"version"` + ExtractedFrom string `json:"extractedFrom"` + Type map[string]any `json:"type"` + Object map[string]any `json:"object"` // WidgetObject with all property values +} + +// templateCache caches loaded templates. +var ( + templateCache = make(map[string]*WidgetTemplate) + templateCacheLock sync.RWMutex +) + +// widgetTemplateIndex maps widget IDs to template filenames. +// Built lazily by scanning embedded template JSON files. +var ( + widgetTemplateIndex map[string]string + widgetTemplateIndexOnce sync.Once +) + +// getWidgetTemplateIndex returns the widget ID → filename mapping, +// built by scanning all embedded JSON templates for their "widgetId" field. +func getWidgetTemplateIndex() map[string]string { + widgetTemplateIndexOnce.Do(func() { + widgetTemplateIndex = make(map[string]string) + entries, err := templateFS.ReadDir("templates/mendix-11.6") + if err != nil { + return + } + for _, entry := range entries { + if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".json") { + continue + } + // Read just enough to extract widgetId + data, err := templateFS.ReadFile("templates/mendix-11.6/" + entry.Name()) + if err != nil { + continue + } + var header struct { + WidgetID string `json:"widgetId"` + Type map[string]any `json:"type"` + } + if err := json.Unmarshal(data, &header); err != nil { + continue + } + wid := header.WidgetID + // Fallback: extract WidgetId from type.WidgetId for older templates + if wid == "" && header.Type != nil { + if v, ok := header.Type["WidgetId"].(string); ok { + wid = v + } + } + if wid == "" { + continue + } + widgetTemplateIndex[wid] = entry.Name() + } + }) + return widgetTemplateIndex +} + +// GetTemplate loads a widget template by widget ID. +// Returns nil if the template is not found. +func GetTemplate(widgetID string) (*WidgetTemplate, error) { + // Check cache first + templateCacheLock.RLock() + if tmpl, ok := templateCache[widgetID]; ok { + templateCacheLock.RUnlock() + return tmpl, nil + } + templateCacheLock.RUnlock() + + // Find template file from auto-scanned index + index := getWidgetTemplateIndex() + filename, ok := index[widgetID] + if !ok { + return nil, nil // Not found, not an error + } + + // Load template + data, err := templateFS.ReadFile("templates/mendix-11.6/" + filename) + if err != nil { + return nil, fmt.Errorf("failed to read template %s: %w", filename, err) + } + + var tmpl WidgetTemplate + if err := json.Unmarshal(data, &tmpl); err != nil { + return nil, fmt.Errorf("failed to parse template %s: %w", filename, err) + } + + // Cache the template + templateCacheLock.Lock() + templateCache[widgetID] = &tmpl + templateCacheLock.Unlock() + + return &tmpl, nil +} + +// GetTemplateBSON loads a widget template and converts its type definition to BSON. +// The returned bson.D can be used directly in widget creation. +// IDs in the template are regenerated with new UUIDs while preserving internal references. +// If projectPath is non-empty, the template is augmented from the project's .mpk widget file. +func GetTemplateBSON(widgetID string, idGenerator func() string, projectPath string) (bson.D, map[string]PropertyTypeIDEntry, error) { + tmpl, err := GetTemplate(widgetID) + if err != nil { + return nil, nil, err + } + if tmpl == nil { + return nil, nil, nil + } + + // Deep-clone and augment from .mpk + tmpl = augmentFromMPK(tmpl, widgetID, projectPath) + + // Phase 1: Collect all $ID values and create old->new ID mappings + idMapping := make(map[string]string) + collectIDs(tmpl.Type, idGenerator, idMapping) + + // Phase 2: Convert JSON to BSON, replacing IDs using the mapping + propertyTypeIDs := make(map[string]PropertyTypeIDEntry) + bsonType := jsonToBSONWithMapping(tmpl.Type, idMapping, propertyTypeIDs) + + if containsPlaceholderID(bsonType) { + return nil, nil, fmt.Errorf("placeholder ID leak detected in widget template type for %s: aa000000-prefix ID was not remapped", widgetID) + } + + return bsonType, propertyTypeIDs, nil +} + +// GetTemplateFullBSON loads a widget template and converts both Type and Object to BSON. +// The returned bson.D values can be used directly in widget creation. +// IDs in the template are regenerated with new UUIDs while preserving internal references. +// If projectPath is non-empty, the template is augmented from the project's .mpk widget file. +// Returns: (clonedType, clonedObject, propertyTypeIDs, objectTypeID, error) +func GetTemplateFullBSON(widgetID string, idGenerator func() string, projectPath string) (bson.D, bson.D, map[string]PropertyTypeIDEntry, string, error) { + tmpl, err := GetTemplate(widgetID) + if err != nil { + return nil, nil, nil, "", err + } + if tmpl == nil { + return nil, nil, nil, "", nil + } + + // Deep-clone and augment from .mpk + tmpl = augmentFromMPK(tmpl, widgetID, projectPath) + + // Phase 1: Collect all $ID values from Type and create old->new ID mappings + idMapping := make(map[string]string) + collectIDs(tmpl.Type, idGenerator, idMapping) + + // Also collect IDs from Object + if tmpl.Object != nil { + collectIDs(tmpl.Object, idGenerator, idMapping) + } + + // Phase 2: Convert Type JSON to BSON, replacing IDs using the mapping + propertyTypeIDs := make(map[string]PropertyTypeIDEntry) + var objectTypeID string + bsonType := jsonToBSONWithMappingAndObjectType(tmpl.Type, idMapping, propertyTypeIDs, &objectTypeID) + + // Phase 3: Convert Object JSON to BSON, replacing IDs using the mapping + var bsonObject bson.D + if tmpl.Object != nil { + bsonObject = jsonToBSONObjectWithMapping(tmpl.Object, idMapping) + } + + if containsPlaceholderID(bsonType) { + return nil, nil, nil, "", fmt.Errorf("placeholder ID leak detected in widget template type for %s: aa000000-prefix ID was not remapped", widgetID) + } + if bsonObject != nil && containsPlaceholderID(bsonObject) { + return nil, nil, nil, "", fmt.Errorf("placeholder ID leak detected in widget template object for %s: aa000000-prefix ID was not remapped", widgetID) + } + + return bsonType, bsonObject, propertyTypeIDs, objectTypeID, nil +} + +// jsonToBSONWithMappingAndObjectType converts Type JSON to BSON and extracts the ObjectType ID. +func jsonToBSONWithMappingAndObjectType(data map[string]any, idMapping map[string]string, propertyTypeIDs map[string]PropertyTypeIDEntry, objectTypeID *string) bson.D { + result := make(bson.D, 0, len(data)) + + // Track if this is a PropertyType or ObjectType + var isPropertyType bool + var isObjectType bool + var propertyKey string + var propertyTypeIDVal string + var valueTypeID string + var defaultValue string + var valueType string + var required bool + var nestedObjectTypeID string + var nestedPropertyIDs map[string]PropertyTypeIDEntry + + // First pass: detect type + if typeVal, ok := data["$Type"]; ok { + if typeStr, ok := typeVal.(string); ok { + if typeStr == "CustomWidgets$WidgetPropertyType" { + isPropertyType = true + } else if typeStr == "CustomWidgets$WidgetObjectType" { + isObjectType = true + } + } + } + if keyVal, ok := data["PropertyKey"]; ok { + if keyStr, ok := keyVal.(string); ok { + propertyKey = keyStr + } + } + + // Convert each field in sorted order for deterministic BSON output + for _, key := range sortedMapKeys(data) { + val := data[key] + elem := bson.E{Key: key} + + if key == "$ID" { + // Convert hex ID to binary, using mapping + if oldID, ok := val.(string); ok { + newID := idMapping[oldID] + if newID == "" { + newID = oldID + } + elem.Value = hexToIDBlob(newID) + + if isPropertyType { + propertyTypeIDVal = newID + } + if isObjectType && objectTypeID != nil { + *objectTypeID = newID + } + } + } else if key == "ValueType" && isPropertyType { + // For PropertyTypes, extract ValueType info including nested ObjectType, DefaultValue, Type, Required + nestedPropertyIDs = make(map[string]PropertyTypeIDEntry) + elem.Value = jsonValueToBSONWithNestedObjectType(val, idMapping, &valueTypeID, &nestedObjectTypeID, nestedPropertyIDs, &defaultValue, &valueType, &required) + } else { + elem.Value = jsonValueToBSONWithMappingAndObjectType(val, idMapping, propertyTypeIDs, &valueTypeID, key == "ValueType", objectTypeID) + } + + result = append(result, elem) + } + + // Record PropertyType IDs + if isPropertyType && propertyKey != "" { + entry := PropertyTypeIDEntry{ + PropertyTypeID: propertyTypeIDVal, + ValueTypeID: valueTypeID, + DefaultValue: defaultValue, + ValueType: valueType, + Required: required, + } + if nestedObjectTypeID != "" { + entry.ObjectTypeID = nestedObjectTypeID + entry.NestedPropertyIDs = nestedPropertyIDs + } + propertyTypeIDs[propertyKey] = entry + } + + return result +} + +// jsonValueToBSONWithNestedObjectType extracts ValueType info including nested ObjectType, DefaultValue, and Type. +func jsonValueToBSONWithNestedObjectType(val any, idMapping map[string]string, valueTypeID *string, nestedObjectTypeID *string, nestedPropertyIDs map[string]PropertyTypeIDEntry, defaultValue *string, valueType *string, required *bool) any { + switch v := val.(type) { + case map[string]any: + result := make(bson.D, 0, len(v)) + + // Extract IDs and metadata from ValueType in sorted order + for _, key := range sortedMapKeys(v) { + fieldVal := v[key] + elem := bson.E{Key: key} + + if key == "$ID" { + if oldID, ok := fieldVal.(string); ok { + newID := idMapping[oldID] + if newID == "" { + newID = oldID + } + elem.Value = hexToIDBlob(newID) + *valueTypeID = newID + } + } else if key == "ObjectType" { + // Extract nested ObjectType and its PropertyTypes + elem.Value = extractNestedObjectType(fieldVal, idMapping, nestedObjectTypeID, nestedPropertyIDs) + } else if key == "DefaultValue" { + // Extract default value + if dv, ok := fieldVal.(string); ok { + *defaultValue = dv + } + elem.Value = jsonValueToBSONSimple(fieldVal, idMapping) + } else if key == "Type" { + // Extract value type + if vt, ok := fieldVal.(string); ok { + *valueType = vt + } + elem.Value = jsonValueToBSONSimple(fieldVal, idMapping) + } else if key == "Required" { + // Extract required flag + if r, ok := fieldVal.(bool); ok { + *required = r + } + elem.Value = jsonValueToBSONSimple(fieldVal, idMapping) + } else { + elem.Value = jsonValueToBSONSimple(fieldVal, idMapping) + } + + result = append(result, elem) + } + return result + + default: + return jsonValueToBSONSimple(val, idMapping) + } +} + +// extractNestedObjectType extracts ObjectType ID and its PropertyType IDs. +func extractNestedObjectType(val any, idMapping map[string]string, objectTypeID *string, nestedPropertyIDs map[string]PropertyTypeIDEntry) any { + if val == nil { + return nil + } + + objType, ok := val.(map[string]any) + if !ok { + return jsonValueToBSONSimple(val, idMapping) + } + + result := make(bson.D, 0, len(objType)) + + for _, key := range sortedMapKeys(objType) { + fieldVal := objType[key] + elem := bson.E{Key: key} + + if key == "$ID" { + if oldID, ok := fieldVal.(string); ok { + newID := idMapping[oldID] + if newID == "" { + newID = oldID + } + elem.Value = hexToIDBlob(newID) + *objectTypeID = newID + } + } else if key == "PropertyTypes" { + // Extract PropertyTypes within the nested ObjectType + elem.Value = extractNestedPropertyTypes(fieldVal, idMapping, nestedPropertyIDs) + } else { + elem.Value = jsonValueToBSONSimple(fieldVal, idMapping) + } + + result = append(result, elem) + } + + return result +} + +// extractNestedPropertyTypes extracts PropertyType IDs from a nested ObjectType's PropertyTypes array. +func extractNestedPropertyTypes(val any, idMapping map[string]string, nestedPropertyIDs map[string]PropertyTypeIDEntry) any { + arr, ok := val.([]any) + if !ok { + return jsonValueToBSONSimple(val, idMapping) + } + + result := make(bson.A, len(arr)) + for i, item := range arr { + if propType, ok := item.(map[string]any); ok { + // Extract property key and IDs + var propKey, propTypeID, valueTypeID string + + if typeVal, ok := propType["$Type"]; ok { + if typeStr, ok := typeVal.(string); ok && typeStr == "CustomWidgets$WidgetPropertyType" { + if keyVal, ok := propType["PropertyKey"]; ok { + if keyStr, ok := keyVal.(string); ok { + propKey = keyStr + } + } + if idVal, ok := propType["$ID"]; ok { + if oldID, ok := idVal.(string); ok { + newID := idMapping[oldID] + if newID == "" { + newID = oldID + } + propTypeID = newID + } + } + // Extract ValueType ID + if vtVal, ok := propType["ValueType"]; ok { + if vt, ok := vtVal.(map[string]any); ok { + if vtID, ok := vt["$ID"]; ok { + if oldID, ok := vtID.(string); ok { + newID := idMapping[oldID] + if newID == "" { + newID = oldID + } + valueTypeID = newID + } + } + } + } + + // Extract DefaultValue, Type, and Required from nested ValueType + var nestedDefaultValue, nestedValueType string + var nestedRequired bool + if vtVal, ok := propType["ValueType"]; ok { + if vt, ok := vtVal.(map[string]any); ok { + if dv, ok := vt["DefaultValue"].(string); ok { + nestedDefaultValue = dv + } + if t, ok := vt["Type"].(string); ok { + nestedValueType = t + } + if r, ok := vt["Required"].(bool); ok { + nestedRequired = r + } + } + } + + // Record the nested property type + if propKey != "" { + nestedPropertyIDs[propKey] = PropertyTypeIDEntry{ + PropertyTypeID: propTypeID, + ValueTypeID: valueTypeID, + DefaultValue: nestedDefaultValue, + ValueType: nestedValueType, + Required: nestedRequired, + } + } + } + } + + // Convert the property type to BSON + result[i] = jsonValueToBSONSimple(item, idMapping) + } else { + result[i] = jsonValueToBSONSimple(item, idMapping) + } + } + + return result +} + +// jsonValueToBSONSimple converts a JSON value to BSON without special tracking. +func jsonValueToBSONSimple(val any, idMapping map[string]string) any { + switch v := val.(type) { + case map[string]any: + result := make(bson.D, 0, len(v)) + for _, key := range sortedMapKeys(v) { + fieldVal := v[key] + elem := bson.E{Key: key} + if key == "$ID" { + if oldID, ok := fieldVal.(string); ok { + newID := idMapping[oldID] + if newID == "" { + newID = oldID + } + elem.Value = hexToIDBlob(newID) + } + } else { + elem.Value = jsonValueToBSONSimple(fieldVal, idMapping) + } + result = append(result, elem) + } + return result + + case []any: + arr := make(bson.A, len(v)) + for i, item := range v { + arr[i] = jsonValueToBSONSimple(item, idMapping) + } + return arr + + case string: + if len(v) == 32 && isHexString(v) { + if newID, ok := idMapping[v]; ok { + return hexToIDBlob(newID) + } + } + return v + + case float64: + if v == float64(int64(v)) { + return int32(v) + } + return v + + default: + return v + } +} + +// jsonValueToBSONWithMappingAndObjectType converts a JSON value to BSON with ObjectType tracking. +func jsonValueToBSONWithMappingAndObjectType(val any, idMapping map[string]string, propertyTypeIDs map[string]PropertyTypeIDEntry, valueTypeID *string, isValueType bool, objectTypeID *string) any { + switch v := val.(type) { + case map[string]any: + result := jsonToBSONWithMappingAndObjectType(v, idMapping, propertyTypeIDs, objectTypeID) + if isValueType { + for _, elem := range result { + if elem.Key == "$ID" { + if blob, ok := elem.Value.([]byte); ok { + *valueTypeID = blobToHex(blob) + } + } + } + } + return result + + case []any: + arr := make(bson.A, len(v)) + for i, item := range v { + arr[i] = jsonValueToBSONWithMappingAndObjectType(item, idMapping, propertyTypeIDs, valueTypeID, false, objectTypeID) + } + return arr + + case string: + if len(v) == 32 && isHexString(v) { + if newID, ok := idMapping[v]; ok { + return hexToIDBlob(newID) + } + } + return v + + case float64: + if v == float64(int64(v)) { + return int32(v) + } + return v + + default: + return v + } +} + +// jsonToBSONObjectWithMapping converts Object JSON to BSON with ID mapping for TypePointers. +func jsonToBSONObjectWithMapping(data map[string]any, idMapping map[string]string) bson.D { + result := make(bson.D, 0, len(data)) + + for _, key := range sortedMapKeys(data) { + val := data[key] + elem := bson.E{Key: key} + + if key == "$ID" { + if oldID, ok := val.(string); ok { + newID := idMapping[oldID] + if newID == "" { + newID = oldID + } + elem.Value = hexToIDBlob(newID) + } + } else if key == "TypePointer" { + // TypePointer references IDs in the Type - use mapping + if oldID, ok := val.(string); ok { + newID := idMapping[oldID] + if newID == "" { + newID = oldID + } + elem.Value = hexToIDBlob(newID) + } else { + elem.Value = val + } + } else { + elem.Value = jsonValueToBSONObjectWithMapping(val, idMapping) + } + + result = append(result, elem) + } + + return result +} + +// jsonValueToBSONObjectWithMapping converts Object JSON values to BSON. +func jsonValueToBSONObjectWithMapping(val any, idMapping map[string]string) any { + switch v := val.(type) { + case map[string]any: + return jsonToBSONObjectWithMapping(v, idMapping) + + case []any: + arr := make(bson.A, len(v)) + for i, item := range v { + arr[i] = jsonValueToBSONObjectWithMapping(item, idMapping) + } + return arr + + case string: + // Check if this looks like an ID reference + if len(v) == 32 && isHexString(v) { + if newID, ok := idMapping[v]; ok { + return hexToIDBlob(newID) + } + } + return v + + case float64: + if v == float64(int64(v)) { + return int32(v) + } + return v + + default: + return v + } +} + +// PropertyTypeIDEntry holds the IDs for a property type. +type PropertyTypeIDEntry struct { + PropertyTypeID string + ValueTypeID string + DefaultValue string // Default value from the template's ValueType + ValueType string // Type of value (Boolean, Integer, String, DataSource, etc.) + Required bool // Whether this property is required + // For object list properties (IsList=true with ObjectType), these hold nested IDs + ObjectTypeID string // ID of the nested ObjectType (for object lists) + NestedPropertyIDs map[string]PropertyTypeIDEntry // Property IDs within the nested ObjectType +} + +// collectIDs recursively collects all $ID values and creates old->new mappings. +func collectIDs(data map[string]any, idGenerator func() string, idMapping map[string]string) { + for key, val := range data { + if key == "$ID" { + if oldID, ok := val.(string); ok && len(oldID) == 32 { + // Generate new ID for this $ID field. + // Accept any 32-char string (not just valid hex) to handle + // manually crafted placeholder IDs in templates. + newID := idGenerator() + idMapping[oldID] = newID + } + } + + // Recurse into nested structures + switch v := val.(type) { + case map[string]any: + collectIDs(v, idGenerator, idMapping) + case []any: + collectIDsInArray(v, idGenerator, idMapping) + } + } +} + +// collectIDsInArray recursively collects IDs from an array. +func collectIDsInArray(arr []any, idGenerator func() string, idMapping map[string]string) { + for _, item := range arr { + switch v := item.(type) { + case map[string]any: + collectIDs(v, idGenerator, idMapping) + case []any: + collectIDsInArray(v, idGenerator, idMapping) + } + } +} + +// jsonToBSONWithMapping converts a JSON map to bson.D, replacing IDs using the mapping. +func jsonToBSONWithMapping(data map[string]any, idMapping map[string]string, propertyTypeIDs map[string]PropertyTypeIDEntry) bson.D { + result := make(bson.D, 0, len(data)) + + // Track if this is a PropertyType + var isPropertyType bool + var propertyKey string + var propertyTypeID string + var valueTypeID string + + // First pass: detect PropertyType and its key + if typeVal, ok := data["$Type"]; ok { + if typeStr, ok := typeVal.(string); ok && typeStr == "CustomWidgets$WidgetPropertyType" { + isPropertyType = true + } + } + if keyVal, ok := data["PropertyKey"]; ok { + if keyStr, ok := keyVal.(string); ok { + propertyKey = keyStr + } + } + + // Convert each field in sorted order for deterministic BSON output + for _, key := range sortedMapKeys(data) { + val := data[key] + elem := bson.E{Key: key} + + if key == "$ID" { + // Convert hex ID to binary, using mapping + if oldID, ok := val.(string); ok { + newID := idMapping[oldID] + if newID == "" { + newID = oldID // Fallback if not in mapping + } + elem.Value = hexToIDBlob(newID) + + // Track IDs for PropertyType + if isPropertyType { + propertyTypeID = newID + } + } + } else { + elem.Value = jsonValueToBSONWithMapping(val, idMapping, propertyTypeIDs, &valueTypeID, key == "ValueType") + } + + result = append(result, elem) + } + + // Record PropertyType IDs + if isPropertyType && propertyKey != "" { + propertyTypeIDs[propertyKey] = PropertyTypeIDEntry{ + PropertyTypeID: propertyTypeID, + ValueTypeID: valueTypeID, + } + } + + return result +} + +// jsonValueToBSONWithMapping converts a JSON value to a BSON value, replacing IDs using mapping. +func jsonValueToBSONWithMapping(val any, idMapping map[string]string, propertyTypeIDs map[string]PropertyTypeIDEntry, valueTypeID *string, isValueType bool) any { + switch v := val.(type) { + case map[string]any: + result := jsonToBSONWithMapping(v, idMapping, propertyTypeIDs) + // If this is a ValueType, extract its new ID + if isValueType { + for _, elem := range result { + if elem.Key == "$ID" { + if blob, ok := elem.Value.([]byte); ok { + *valueTypeID = blobToHex(blob) + } + } + } + } + return result + + case []any: + arr := make(bson.A, len(v)) + for i, item := range v { + arr[i] = jsonValueToBSONWithMapping(item, idMapping, propertyTypeIDs, valueTypeID, false) + } + return arr + + case string: + // Check if this is a reference to an ID (32 hex chars) + if len(v) == 32 && isHexString(v) { + // Look up in mapping - if found, it's an ID reference + if newID, ok := idMapping[v]; ok { + return hexToIDBlob(newID) + } + } + return v + + case float64: + // JSON numbers are float64, convert to int if it's a whole number + if v == float64(int64(v)) { + return int32(v) + } + return v + + default: + return v + } +} + +// hexToIDBlob converts a hex string (UUID format) to a binary blob for BSON ID. +// The first 3 segments of the UUID are stored in little-endian format (Microsoft GUID), +// matching the format expected by blobToUUID in sdk/mpr/reader.go. +func hexToIDBlob(hexStr string) []byte { + // Remove any dashes from UUID format + hexStr = strings.ReplaceAll(hexStr, "-", "") + data, err := hex.DecodeString(hexStr) + if err != nil { + return nil + } + if len(data) != 16 { + return data + } + + // Swap bytes to match Microsoft GUID format (little-endian for first 3 segments) + // This ensures round-trip compatibility: hexToIDBlob -> blobToUUID returns original hex + // Segment 1 (4 bytes): swap [0,1,2,3] -> [3,2,1,0] + data[0], data[1], data[2], data[3] = data[3], data[2], data[1], data[0] + // Segment 2 (2 bytes): swap [4,5] -> [5,4] + data[4], data[5] = data[5], data[4] + // Segment 3 (2 bytes): swap [6,7] -> [7,6] + data[6], data[7] = data[7], data[6] + // Segments 4 and 5 (2+6 bytes): no swap needed + + return data +} + +// blobToHex converts a binary blob to a hex string. +func blobToHex(data []byte) string { + return hex.EncodeToString(data) +} + +// isHexString checks if a string is a valid hex string. +func isHexString(s string) bool { + for _, c := range s { + if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) { + return false + } + } + return true +} + +// augmentFromMPK deep-clones a template and augments it from the project's .mpk file. +// Returns the original template if augmentation is not applicable or fails. +func augmentFromMPK(tmpl *WidgetTemplate, widgetID string, projectPath string) *WidgetTemplate { + if projectPath == "" { + return tmpl + } + + projectDir := filepath.Dir(projectPath) + mpkPath, err := mpk.FindMPK(projectDir, widgetID) + if err != nil || mpkPath == "" { + return tmpl + } + + def, err := mpk.ParseMPK(mpkPath) + if err != nil { + return tmpl + } + + // Deep-clone so we don't mutate the cached template + clone, err := deepCloneTemplate(tmpl) + if err != nil { + log.Printf("widget.clone_failed: widget_id=%s error=%s", widgetID, err.Error()) + return tmpl + } + if err := AugmentTemplate(clone, def); err != nil { + log.Printf("widget.augment_failed: widget_id=%s error=%s", widgetID, err.Error()) + return tmpl + } + + return clone +} + +// ListAvailableTemplates returns a list of available widget template IDs. +func ListAvailableTemplates() []string { + index := getWidgetTemplateIndex() + result := make([]string, 0, len(index)) + for widgetID := range index { + result = append(result, widgetID) + } + return result +} diff --git a/modelsdk/widgets/mpk/mpk.go b/modelsdk/widgets/mpk/mpk.go new file mode 100644 index 00000000..944a6bd6 --- /dev/null +++ b/modelsdk/widgets/mpk/mpk.go @@ -0,0 +1,476 @@ +// SPDX-License-Identifier: Apache-2.0 + +// Package mpk parses Mendix .mpk widget packages to extract widget property definitions. +// An .mpk file is a ZIP archive containing package.xml (manifest) and a widget XML file +// that defines the widget's properties, types, and metadata. +package mpk + +import ( + "archive/zip" + "encoding/xml" + "fmt" + "io" + "path/filepath" + "strings" + "sync" +) + +// PropertyDef describes a single property from a widget XML definition. +type PropertyDef struct { + Key string // e.g. "staticDataSourceCaption" + Type string // XML type: "attribute", "expression", "textTemplate", "widgets", etc. + Caption string + Description string + Category string // from enclosing propertyGroup captions, joined with "::" + Required bool + DefaultValue string // for enumeration/boolean/integer types + IsList bool + IsSystem bool // true for elements + DataSource string // dataSource attribute reference + Children []PropertyDef // nested properties for object-type properties +} + +// WidgetDefinition holds the parsed definition of a pluggable widget from an .mpk file. +type WidgetDefinition struct { + ID string // e.g. "com.mendix.widget.web.combobox.Combobox" + Name string // e.g. "Combo box" + Version string // from package.xml clientModule version + IsPluggable bool // true if pluginWidget="true" (React), false for legacy Dojo + Properties []PropertyDef // regular elements + SystemProps []PropertyDef // elements +} + +// --- XML structures for parsing --- + +// xmlPackage represents root element. +type xmlPackage struct { + ClientModule xmlClientModule `xml:"clientModule"` +} + +// xmlClientModule represents element. +type xmlClientModule struct { + Name string `xml:"name,attr"` + Version string `xml:"version,attr"` + WidgetFiles []xmlWidgetFile `xml:"widgetFiles>widgetFile"` +} + +// xmlWidgetFile represents element. +type xmlWidgetFile struct { + Path string `xml:"path,attr"` +} + +// xmlWidget represents root element in widget XML. +type xmlWidget struct { + ID string `xml:"id,attr"` + PluginWidget string `xml:"pluginWidget,attr"` + Name string `xml:"name"` + PropertyGroups []xmlPropGroup `xml:"properties>propertyGroup"` +} + +// xmlPropGroup represents element. +type xmlPropGroup struct { + Caption string `xml:"caption,attr"` + Properties []xmlProperty `xml:"property"` + SystemProps []xmlSystemProp `xml:"systemProperty"` + SubGroups []xmlPropGroup `xml:"propertyGroup"` +} + +// xmlProperty represents element. +type xmlProperty struct { + Key string `xml:"key,attr"` + Type string `xml:"type,attr"` + DefaultValue string `xml:"defaultValue,attr"` + Required string `xml:"required,attr"` + IsList string `xml:"isList,attr"` + DataSource string `xml:"dataSource,attr"` + Caption string `xml:"caption"` + Description string `xml:"description"` + // Nested properties for object type + NestedProps []xmlPropGroup `xml:"properties>propertyGroup"` +} + +// xmlSystemProp represents element. +type xmlSystemProp struct { + Key string `xml:"key,attr"` +} + +// Zip extraction limits to prevent zip-bomb attacks. +const ( + maxFileSize = 50 << 20 // 50MB per individual file + maxTotalSize = 200 << 20 // 200MB total extracted +) + +// --- Caching --- + +var ( + defCache = make(map[string]*WidgetDefinition) // mpkPath -> definition + defCacheLock sync.RWMutex + + dirCache = make(map[string]map[string]string) // projectDir -> (widgetID -> mpkPath) + dirCacheLock sync.RWMutex +) + +// ParseMPK opens an .mpk ZIP archive, finds the widget XML, and parses it. +func ParseMPK(mpkPath string) (*WidgetDefinition, error) { + // Check cache + defCacheLock.RLock() + if def, ok := defCache[mpkPath]; ok { + defCacheLock.RUnlock() + return def, nil + } + defCacheLock.RUnlock() + + r, err := zip.OpenReader(mpkPath) + if err != nil { + return nil, fmt.Errorf("failed to open mpk: %w", err) + } + defer r.Close() + + // Parse package.xml to find widget file path and version + var pkg xmlPackage + var widgetFilePath string + var version string + var totalExtracted uint64 + + for _, f := range r.File { + if f.Name == "package.xml" { + if f.UncompressedSize64 > maxFileSize { + return nil, fmt.Errorf("package.xml exceeds max file size (%d > %d)", f.UncompressedSize64, maxFileSize) + } + rc, err := f.Open() + if err != nil { + return nil, fmt.Errorf("failed to open package.xml: %w", err) + } + data, err := io.ReadAll(rc) + rc.Close() + if err != nil { + return nil, fmt.Errorf("failed to read package.xml: %w", err) + } + totalExtracted += uint64(len(data)) + if totalExtracted > maxTotalSize { + return nil, fmt.Errorf("total extracted size exceeds limit (%d > %d)", totalExtracted, maxTotalSize) + } + if err := xml.Unmarshal(data, &pkg); err != nil { + return nil, fmt.Errorf("failed to parse package.xml: %w", err) + } + version = pkg.ClientModule.Version + if len(pkg.ClientModule.WidgetFiles) > 0 { + widgetFilePath = pkg.ClientModule.WidgetFiles[0].Path + } + break + } + } + + if widgetFilePath == "" { + return nil, fmt.Errorf("no widget file path found in package.xml") + } + + // Parse widget XML + for _, f := range r.File { + if f.Name == widgetFilePath { + if f.UncompressedSize64 > maxFileSize { + return nil, fmt.Errorf("%s exceeds max file size (%d > %d)", widgetFilePath, f.UncompressedSize64, maxFileSize) + } + rc, err := f.Open() + if err != nil { + return nil, fmt.Errorf("failed to open %s: %w", widgetFilePath, err) + } + data, err := io.ReadAll(rc) + rc.Close() + if err != nil { + return nil, fmt.Errorf("failed to read %s: %w", widgetFilePath, err) + } + totalExtracted += uint64(len(data)) + if totalExtracted > maxTotalSize { + return nil, fmt.Errorf("total extracted size exceeds limit (%d > %d)", totalExtracted, maxTotalSize) + } + + var widget xmlWidget + if err := xml.Unmarshal(data, &widget); err != nil { + return nil, fmt.Errorf("failed to parse %s: %w", widgetFilePath, err) + } + + def := &WidgetDefinition{ + ID: widget.ID, + Name: widget.Name, + Version: version, + IsPluggable: widget.PluginWidget == "true", + } + + // Walk property groups to collect properties + for _, pg := range widget.PropertyGroups { + walkPropertyGroup(pg, "", def) + } + + // Cache + defCacheLock.Lock() + defCache[mpkPath] = def + defCacheLock.Unlock() + + return def, nil + } + } + + return nil, fmt.Errorf("widget file %s not found in mpk", widgetFilePath) +} + +// walkPropertyGroup recursively walks property groups to collect properties. +func walkPropertyGroup(pg xmlPropGroup, parentCategory string, def *WidgetDefinition) { + category := pg.Caption + if parentCategory != "" && category != "" { + category = parentCategory + "::" + category + } else if parentCategory != "" { + category = parentCategory + } + + // Collect regular properties + for _, p := range pg.Properties { + prop := PropertyDef{ + Key: p.Key, + Type: p.Type, + Caption: p.Caption, + Description: p.Description, + Category: category, + Required: p.Required == "true", + DefaultValue: p.DefaultValue, + IsList: p.IsList == "true", + DataSource: p.DataSource, + } + + // Parse nested properties for object-type properties + if p.Type == "object" && len(p.NestedProps) > 0 { + for _, npg := range p.NestedProps { + collectNestedProperties(npg, &prop) + } + } + + def.Properties = append(def.Properties, prop) + } + + // Collect system properties + for _, sp := range pg.SystemProps { + def.SystemProps = append(def.SystemProps, PropertyDef{ + Key: sp.Key, + IsSystem: true, + Category: category, + }) + } + + // Recurse into subgroups + for _, sub := range pg.SubGroups { + walkPropertyGroup(sub, category, def) + } +} + +// collectNestedProperties extracts child properties from nested propertyGroups +// within an object-type property and appends them to the parent PropertyDef. +func collectNestedProperties(pg xmlPropGroup, parent *PropertyDef) { + for _, p := range pg.Properties { + child := PropertyDef{ + Key: p.Key, + Type: p.Type, + Caption: p.Caption, + Description: p.Description, + Required: p.Required == "true", + DefaultValue: p.DefaultValue, + IsList: p.IsList == "true", + DataSource: p.DataSource, + } + parent.Children = append(parent.Children, child) + } + + for _, sub := range pg.SubGroups { + collectNestedProperties(sub, parent) + } +} + +// FindMPK looks in the project's widgets/ directory for an .mpk matching the widgetID. +// Returns the path to the .mpk file, or empty string if not found. +func FindMPK(projectDir string, widgetID string) (string, error) { + // Check directory cache + dirCacheLock.RLock() + if dirMap, ok := dirCache[projectDir]; ok { + if mpkPath, ok := dirMap[widgetID]; ok { + dirCacheLock.RUnlock() + return mpkPath, nil + } + dirCacheLock.RUnlock() + // Already scanned this dir, widget not found + return "", nil + } + dirCacheLock.RUnlock() + + // Scan widgets/ directory + widgetsDir := filepath.Join(projectDir, "widgets") + matches, err := filepath.Glob(filepath.Join(widgetsDir, "*.mpk")) + if err != nil { + return "", fmt.Errorf("failed to scan widgets directory: %w", err) + } + + // Build mapping by parsing each .mpk's package.xml and widget XML + dirMap := make(map[string]string) + for _, mpkPath := range matches { + wid, err := getWidgetIDFromMPK(mpkPath) + if err != nil { + continue // Skip unparseable files + } + if wid != "" { + dirMap[wid] = mpkPath + } + } + + // Cache the mapping + dirCacheLock.Lock() + dirCache[projectDir] = dirMap + dirCacheLock.Unlock() + + return dirMap[widgetID], nil +} + +// getWidgetIDFromMPK extracts the widget ID from an .mpk file without fully parsing it. +func getWidgetIDFromMPK(mpkPath string) (string, error) { + r, err := zip.OpenReader(mpkPath) + if err != nil { + return "", err + } + defer r.Close() + + // Find package.xml to get widget file path + var widgetFilePath string + var totalExtracted uint64 + for _, f := range r.File { + if f.Name == "package.xml" { + if f.UncompressedSize64 > maxFileSize { + return "", fmt.Errorf("package.xml exceeds max file size (%d > %d)", f.UncompressedSize64, maxFileSize) + } + rc, err := f.Open() + if err != nil { + return "", err + } + data, err := io.ReadAll(rc) + rc.Close() + if err != nil { + return "", err + } + totalExtracted += uint64(len(data)) + if totalExtracted > maxTotalSize { + return "", fmt.Errorf("total extracted size exceeds limit (%d > %d)", totalExtracted, maxTotalSize) + } + var pkg xmlPackage + if err := xml.Unmarshal(data, &pkg); err != nil { + return "", err + } + if len(pkg.ClientModule.WidgetFiles) > 0 { + widgetFilePath = pkg.ClientModule.WidgetFiles[0].Path + } + break + } + } + + if widgetFilePath == "" { + return "", nil + } + + // Read widget XML to get the id attribute + for _, f := range r.File { + if f.Name == widgetFilePath { + if f.UncompressedSize64 > maxFileSize { + return "", fmt.Errorf("%s exceeds max file size (%d > %d)", widgetFilePath, f.UncompressedSize64, maxFileSize) + } + rc, err := f.Open() + if err != nil { + return "", err + } + data, err := io.ReadAll(rc) + rc.Close() + if err != nil { + return "", err + } + totalExtracted += uint64(len(data)) + if totalExtracted > maxTotalSize { + return "", fmt.Errorf("total extracted size exceeds limit (%d > %d)", totalExtracted, maxTotalSize) + } + + // Quick XML parse to just get the id attribute + var widget struct { + ID string `xml:"id,attr"` + } + if err := xml.Unmarshal(data, &widget); err != nil { + return "", err + } + return widget.ID, nil + } + } + + return "", nil +} + +// PropertyKeys returns a set of regular (non-system) property keys from the definition. +func (def *WidgetDefinition) PropertyKeys() map[string]bool { + keys := make(map[string]bool, len(def.Properties)) + for _, p := range def.Properties { + keys[p.Key] = true + } + return keys +} + +// FindProperty returns the PropertyDef for the given key, or nil if not found. +func (def *WidgetDefinition) FindProperty(key string) *PropertyDef { + for i := range def.Properties { + if def.Properties[i].Key == key { + return &def.Properties[i] + } + } + return nil +} + +// SystemPropertyKeys returns a set of system property keys from the definition. +func (def *WidgetDefinition) SystemPropertyKeys() map[string]bool { + keys := make(map[string]bool, len(def.SystemProps)) + for _, p := range def.SystemProps { + keys[p.Key] = true + } + return keys +} + +// ClearCache clears all cached widget definitions and directory mappings. +// Useful for testing or when the project's widgets change. +func ClearCache() { + defCacheLock.Lock() + defCache = make(map[string]*WidgetDefinition) + defCacheLock.Unlock() + + dirCacheLock.Lock() + dirCache = make(map[string]map[string]string) + dirCacheLock.Unlock() +} + +// xmlPropertyTypeMapping maps lowercased XML property type names to their canonical camelCase forms. +var xmlPropertyTypeMapping = map[string]string{ + "attribute": "attribute", + "expression": "expression", + "texttemplate": "textTemplate", + "widgets": "widgets", + "enumeration": "enumeration", + "boolean": "boolean", + "integer": "integer", + "datasource": "datasource", + "action": "action", + "selection": "selection", + "association": "association", + "object": "object", + "string": "string", + "decimal": "decimal", + "icon": "icon", + "image": "image", + "file": "file", +} + +// NormalizeType returns the canonical XML property type name. +func NormalizeType(xmlType string) string { + lower := strings.ToLower(xmlType) + if canonical, ok := xmlPropertyTypeMapping[lower]; ok { + return canonical + } + return xmlType +} diff --git a/modelsdk/widgets/mpk/mpk_test.go b/modelsdk/widgets/mpk/mpk_test.go new file mode 100644 index 00000000..c2fbf222 --- /dev/null +++ b/modelsdk/widgets/mpk/mpk_test.go @@ -0,0 +1,190 @@ +// SPDX-License-Identifier: Apache-2.0 + +package mpk + +import ( + "os" + "path/filepath" + "testing" +) + +// findTestMPK finds a ComboBox .mpk file in the test projects directory. +func findTestMPK(t *testing.T) string { + t.Helper() + // Try multiple known locations + candidates := []string{ + filepath.Join("..", "..", "..", "mx-test-projects", "template-app-116", "widgets", "com.mendix.widget.web.Combobox.mpk"), + filepath.Join("..", "..", "..", "mx-test-projects", "LatoProductInventory", "widgets", "com.mendix.widget.web.Combobox.mpk"), + } + for _, c := range candidates { + if _, err := os.Stat(c); err == nil { + return c + } + } + t.Skip("No test .mpk file found") + return "" +} + +func findTestProjectDir(t *testing.T) string { + t.Helper() + candidates := []string{ + filepath.Join("..", "..", "..", "mx-test-projects", "template-app-116"), + filepath.Join("..", "..", "..", "mx-test-projects", "LatoProductInventory"), + } + for _, c := range candidates { + widgetsDir := filepath.Join(c, "widgets") + if _, err := os.Stat(widgetsDir); err == nil { + return c + } + } + t.Skip("No test project directory found") + return "" +} + +func TestParseMPK(t *testing.T) { + mpkPath := findTestMPK(t) + ClearCache() + + def, err := ParseMPK(mpkPath) + if err != nil { + t.Fatalf("ParseMPK failed: %v", err) + } + + if def.ID != "com.mendix.widget.web.combobox.Combobox" { + t.Errorf("unexpected widget ID: %s", def.ID) + } + + if def.Name != "Combo box" { + t.Errorf("unexpected widget name: %s", def.Name) + } + + if def.Version == "" { + t.Error("version should not be empty") + } + + if len(def.Properties) == 0 { + t.Error("expected at least one property") + } + + // Check that we found some known properties + keys := def.PropertyKeys() + expectedKeys := []string{"source", "attributeEnumeration", "clearable", "filterType"} + for _, k := range expectedKeys { + if !keys[k] { + t.Errorf("expected property key %q not found", k) + } + } + + // Check system properties + if len(def.SystemProps) == 0 { + t.Error("expected at least one system property") + } + sysKeys := def.SystemPropertyKeys() + if !sysKeys["Label"] { + t.Error("expected system property 'Label'") + } + + // Check property types + sourceProp := def.FindProperty("source") + if sourceProp == nil { + t.Fatal("source property not found") + } + if sourceProp.Type != "enumeration" { + t.Errorf("expected source type 'enumeration', got %q", sourceProp.Type) + } + if sourceProp.DefaultValue != "context" { + t.Errorf("expected source default 'context', got %q", sourceProp.DefaultValue) + } + + // Check category tracking + if sourceProp.Category == "" { + t.Error("expected source to have a category") + } +} + +func TestParseMPK_Cached(t *testing.T) { + mpkPath := findTestMPK(t) + ClearCache() + + def1, err := ParseMPK(mpkPath) + if err != nil { + t.Fatalf("first ParseMPK failed: %v", err) + } + + def2, err := ParseMPK(mpkPath) + if err != nil { + t.Fatalf("second ParseMPK failed: %v", err) + } + + // Should return same pointer from cache + if def1 != def2 { + t.Error("expected cached result to return same pointer") + } +} + +func TestFindMPK(t *testing.T) { + projectDir := findTestProjectDir(t) + ClearCache() + + // Find ComboBox + mpkPath, err := FindMPK(projectDir, "com.mendix.widget.web.combobox.Combobox") + if err != nil { + t.Fatalf("FindMPK failed: %v", err) + } + if mpkPath == "" { + t.Fatal("expected to find ComboBox .mpk") + } + if !filepath.IsAbs(mpkPath) && !fileExists(mpkPath) { + t.Errorf("mpk path should exist: %s", mpkPath) + } + + // Find non-existent widget + mpkPath2, err := FindMPK(projectDir, "com.example.nonexistent.Widget") + if err != nil { + t.Fatalf("FindMPK for nonexistent should not error: %v", err) + } + if mpkPath2 != "" { + t.Errorf("expected empty path for nonexistent widget, got: %s", mpkPath2) + } +} + +func TestFindMPK_Cached(t *testing.T) { + projectDir := findTestProjectDir(t) + ClearCache() + + // First call scans directory + path1, _ := FindMPK(projectDir, "com.mendix.widget.web.combobox.Combobox") + // Second call should use cache + path2, _ := FindMPK(projectDir, "com.mendix.widget.web.combobox.Combobox") + + if path1 != path2 { + t.Error("expected same path from cache") + } +} + +func TestNormalizeType(t *testing.T) { + tests := []struct { + input string + expected string + }{ + {"attribute", "attribute"}, + {"Attribute", "attribute"}, + {"ATTRIBUTE", "attribute"}, + {"textTemplate", "textTemplate"}, + {"TextTemplate", "textTemplate"}, + {"datasource", "datasource"}, + {"unknownType", "unknownType"}, + } + + for _, tt := range tests { + result := NormalizeType(tt.input) + if result != tt.expected { + t.Errorf("NormalizeType(%q) = %q, want %q", tt.input, result, tt.expected) + } + } +} + +func fileExists(path string) bool { + _, err := os.Stat(path) + return err == nil +} diff --git a/modelsdk/widgets/placeholder_test.go b/modelsdk/widgets/placeholder_test.go new file mode 100644 index 00000000..e8d726f9 --- /dev/null +++ b/modelsdk/widgets/placeholder_test.go @@ -0,0 +1,62 @@ +// SPDX-License-Identifier: Apache-2.0 + +package widgets + +import ( + "testing" + + "go.mongodb.org/mongo-driver/bson" +) + +func TestContainsPlaceholderID_BinaryBlob(t *testing.T) { + // Create a bson.D with a placeholder binary blob (post-GUID-swap) + // Placeholder "aa000000000000000000000000000001" after hexToIDBlob: + // bytes 0-3 reversed: \x00\x00\x00\xaa, bytes 4-12: zeros, bytes 13-15: \x00\x00\x01 + blob := hexToIDBlob("aa000000000000000000000000000001") + doc := bson.D{{Key: "$ID", Value: blob}} + + if !containsPlaceholderID(doc) { + t.Error("expected containsPlaceholderID to detect placeholder binary blob") + } +} + +func TestContainsPlaceholderID_StringValue(t *testing.T) { + // A placeholder that leaked as a string (e.g., unmapped TypePointer) + doc := bson.D{{Key: "TypePointer", Value: "aa000000000000000000000000000005"}} + + if !containsPlaceholderID(doc) { + t.Error("expected containsPlaceholderID to detect placeholder string value") + } +} + +func TestContainsPlaceholderID_Nested(t *testing.T) { + blob := hexToIDBlob("aa000000000000000000000000000002") + doc := bson.D{ + {Key: "$ID", Value: hexToIDBlob("abcdef01234567890abcdef012345678")}, + {Key: "Children", Value: bson.A{ + bson.D{ + {Key: "$ID", Value: blob}, + {Key: "Name", Value: "test"}, + }, + }}, + } + + if !containsPlaceholderID(doc) { + t.Error("expected containsPlaceholderID to detect nested placeholder blob") + } +} + +func TestContainsPlaceholderID_Clean(t *testing.T) { + // A legitimate UUID should not trigger detection + doc := bson.D{ + {Key: "$ID", Value: hexToIDBlob("abcdef01234567890abcdef012345678")}, + {Key: "Name", Value: "SomeWidget"}, + {Key: "Items", Value: bson.A{ + bson.D{{Key: "$ID", Value: hexToIDBlob("12345678abcdef0012345678abcdef00")}}, + }}, + } + + if containsPlaceholderID(doc) { + t.Error("expected containsPlaceholderID to NOT trigger on legitimate UUIDs") + } +} diff --git a/modelsdk/widgets/templates/README.md b/modelsdk/widgets/templates/README.md new file mode 100644 index 00000000..e48cb458 --- /dev/null +++ b/modelsdk/widgets/templates/README.md @@ -0,0 +1,267 @@ +# Widget Templates + +This directory contains JSON templates for Mendix pluggable widgets. These templates are extracted from a reference Mendix project and embedded into the mxcli binary via `go:embed`. + +## Structure + +``` +templates/ +├── mendix-11.6/ # Templates for Mendix 11.6.x +│ ├── combobox.json # com.mendix.widget.web.combobox.Combobox +│ ├── datagrid.json # com.mendix.widget.web.datagrid.Datagrid +│ ├── gallery.json # com.mendix.widget.web.gallery.Gallery +│ ├── datagrid-text-filter.json # DatagridTextFilter +│ ├── datagrid-date-filter.json # DatagridDateFilter +│ ├── datagrid-dropdown-filter.json +│ └── datagrid-number-filter.json +└── README.md +``` + +## Template Format + +Each template is a JSON file containing **both** the `CustomWidgetType` and `WidgetObject` structures: + +```json +{ + "widgetId": "com.mendix.widget.web.combobox.Combobox", + "name": "Combo box", + "version": "11.6.0", + "extractedFrom": "PageTemplates.Customer_NewEdit", + "type": { + "$ID": "aa000000000000000000000000000001", + "$Type": "CustomWidgets$CustomWidgetType", + "WidgetId": "com.mendix.widget.web.combobox.Combobox", + "PropertyTypes": [ + { + "$ID": "aa000000000000000000000000000010", + "$Type": "CustomWidgets$WidgetPropertyType", + "PropertyKey": "attributeEnumeration", + "ValueType": { + "$ID": "aa000000000000000000000000000011", + "Type": "Attribute", + "DefaultValue": "" + } + } + ] + }, + "object": { + "$ID": "aa000000000000000000000000000100", + "$Type": "CustomWidgets$WidgetObject", + "TypePointer": "aa000000000000000000000000000001", + "Properties": [ + 2, + { + "$ID": "aa000000000000000000000000000110", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "aa000000000000000000000000000010", + "Value": { + "$ID": "aa000000000000000000000000000111", + "$Type": "CustomWidgets$WidgetValue", + "AttributeRef": null, + "DataSource": null, + "PrimitiveValue": "", + "Widgets": [2], + "Selection": "None" + } + } + ] + } +} +``` + +### Why Both `type` AND `object` Are Required + +The `type` field defines the widget's PropertyTypes (schema), while the `object` field contains the actual property values with correct defaults. Studio Pro expects: + +1. **Consistent cross-references**: `object.Properties[].TypePointer` must reference valid `type.PropertyTypes[].$ID` values; `object.TypePointer` must reference `type.$ID` +2. **All properties present**: Every PropertyType in the Type must have a corresponding WidgetProperty in the Object +3. **Correct default values**: Properties like `TextTemplate` need proper `Forms$ClientTemplate` structures, not null + +Without the `object` field, mxcli must build the WidgetObject from scratch, which is error-prone and often triggers CE0463 "widget definition has changed" in Studio Pro. + +### ID Cross-Reference Structure + +``` +Type Object +├─ $ID ◄──────────────────────────── TypePointer (WidgetObject → CustomWidgetType) +└─ PropertyTypes[] └─ Properties[] + ├─ $ID ◄──────────────────────────── TypePointer (WidgetProperty → WidgetPropertyType) + └─ ValueType └─ Value + └─ $ID ◄──────────────────────────── TypePointer (WidgetValue → ValueType) +``` + +At load time, all `$ID` values are remapped to fresh UUIDs. The same mapping is applied to both Type and Object, preserving these cross-references. + +## Runtime Loading Pipeline + +`GetTemplateFullBSON()` in `loader.go` executes a 3-phase pipeline: + +### Phase 1: Collect IDs + +`collectIDs()` recursively walks both `type` and `object` JSON, creates `oldID → newUUID` mapping for every `$ID` field. + +### Phase 2: Convert Type JSON → BSON + +`jsonToBSONWithMappingAndObjectType()` converts the Type, replacing IDs and simultaneously extracting `PropertyTypeIDMap`: + +``` +PropertyTypeIDMap["attributeEnumeration"] = { + PropertyTypeID: "newUUID-010", // remapped $ID of WidgetPropertyType + ValueTypeID: "newUUID-011", // remapped $ID of ValueType + DefaultValue: "", + ValueType: "Attribute", +} +``` + +This map is the bridge between `.def.json` property keys and the BSON structure — the engine uses it to locate which WidgetProperty to modify for each mapping. + +### Phase 3: Convert Object JSON → BSON + +`jsonToBSONObjectWithMapping()` converts the Object using the same ID mapping. `TypePointer` fields are specially handled to ensure they point to the new IDs from Phase 2. + +### Placeholder Leak Detection + +After both phases, `containsPlaceholderID()` checks for any remaining `aa000000`-prefix IDs. If found, the load fails immediately rather than producing a corrupt MPR. + +### MPK Augmentation + +Before the 3-phase pipeline, `augmentFromMPK()` checks if the project has a newer `.mpk` for the widget (in `project/widgets/`). If found, it deep-clones the template and merges property changes from the `.mpk` XML definition, adding missing properties and removing stale ones. This reduces CE0463 from widget version drift. + +## Extracting New Templates + +### Important: Use Studio Pro-Created Widgets + +When extracting templates, **always use widgets that have been created or "fixed" by Studio Pro**. This ensures the WidgetObject contains correct default values. If you programmatically create a widget and extract it, you'll just get the same incorrect structure back. + +### Extraction Process + +1. **Create the widget in Studio Pro** — Add the widget to a page and configure it with default settings + +2. **If updating an existing template** — If Studio Pro shows "widget definition has changed", right-click and select "Update widget" to let Studio Pro fix it + +3. **Extract the BSON**: +```bash +# Dump the page containing the widget +mxcli bson dump -p App.mpr --type page --object "Module.TestPage" --format json + +# Extract the CustomWidget's Type and Object fields from the JSON output +# Save as templates/mendix-11.6/widgetname.json +``` + +4. **Extract skeleton .def.json** (for new widgets): +```bash +mxcli widget extract --mpk widgets/MyWidget.mpk +# Generates .mxcli/widgets/mywidget.def.json with auto-inferred mappings +``` + +### Verifying Templates + +After updating a template, verify it works: + +```bash +# Create a test page with the widget +mxcli -p test.mpr -c "CREATE PAGE Test.TestPage ... COMBOBOX ..." + +# Check for errors (should have no CE0463 errors) +~/.mxcli/mxbuild/*/modeler/mx check test.mpr + +# Compare BSON if issues persist +mxcli bson dump -p test.mpr --type page --object "Test.TestPage" --format ndsl +``` + +## Usage + +Templates are automatically used when creating pluggable widgets via MDL: + +```sql +COMBOBOX myCombo (Label: 'Country', Attribute: Country) +``` + +### 3-Tier Widget Registry + +When creating a pluggable widget, mxcli resolves definitions and templates: + +| Priority | Location | Scope | +|----------|----------|-------| +| 1 (highest) | `/.mxcli/widgets/*.def.json` | Project-specific overrides | +| 2 | `~/.mxcli/widgets/*.def.json` | Global user definitions | +| 3 (lowest) | `sdk/widgets/definitions/*.def.json` (embedded) | Built-in definitions | + +Each `.def.json` declares property mappings and child slots; the `PluggableWidgetEngine` applies them to the BSON template at build time. See `docs/plans/2026-03-25-pluggable-widget-engine-design.md` for the full architecture. + +### Widget Version Drift + +Static templates are tied to the widget version they were extracted from. If the target project has a **newer** `.mpk`, the MPK augmentation mechanism (described above) handles this at runtime by merging property changes from the `.mpk` XML. + +For cases where augmentation is insufficient, extract a fresh template from a Studio Pro project using the newer widget version. + +## TextTemplate Property Requirements + +Properties with `"Type": "TextTemplate"` in the Type definition require special handling. They **cannot** be `null` in the Object section. + +### Problem: CE0463 "widget definition has changed" + +If a TextTemplate property is `null` in the Object section, Studio Pro shows: +``` +CE0463: The definition of this widget has changed. Update this widget... +``` + +### Required Structure + +TextTemplate properties must have a proper `Forms$ClientTemplate` structure: + +```json +"TextTemplate": { + "$ID": "<32-char-guid>", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "<32-char-guid>", + "$Type": "Texts$Text", + "Items": [] + }, + "Parameters": [], + "Template": { + "$ID": "<32-char-guid>", + "$Type": "Texts$Text", + "Items": [] + } +} +``` + +### Important: Empty Arrays + +Empty arrays must be `[]`, NOT `[2]`: +```json +// WRONG - serializes as array containing integer 2 +"Items": [2] + +// CORRECT - truly empty array +"Items": [] +``` + +### How to Identify TextTemplate Properties + +1. Search the Type section for `"Type": "TextTemplate"` +2. Note the `$ID` from the parent `ValueType` object +3. Find Object properties where `Value.TypePointer` matches that ID +4. Update those properties' `TextTemplate` from `null` to proper structure + +### Affected Widgets + +Filter widgets commonly have TextTemplate properties: +- **TextFilter**: `placeholder`, `screenReaderButtonCaption`, `screenReaderInputCaption` +- **DateFilter**: `placeholder`, `screenReaderButtonCaption`, `screenReaderCalendarCaption`, `screenReaderInputCaption` +- **DropdownFilter**: `emptyOptionCaption`, `ariaLabel`, `emptySelectionCaption`, `filterInputPlaceholderCaption` +- **NumberFilter**: `placeholder`, `screenReaderButtonCaption`, `screenReaderInputCaption` + +## Key Source Files + +| File | Purpose | +|------|---------| +| `sdk/widgets/loader.go` | Template loading, 3-phase ID remapping, MPK augmentation, placeholder detection | +| `sdk/widgets/mpk/mpk.go` | .mpk ZIP parsing, XML property extraction, FindMPK | +| `sdk/widgets/definitions/*.def.json` | Built-in widget definition files | +| `mdl/executor/widget_engine.go` | PluggableWidgetEngine, 6 operations, Build() pipeline | +| `mdl/executor/widget_registry.go` | 3-tier WidgetRegistry, load-time validation | +| `mdl/executor/cmd_pages_builder_input.go` | `updateWidgetPropertyValue()`, TypePointer matching | +| `cmd/mxcli/cmd_widget.go` | `mxcli widget extract/list` CLI commands | diff --git a/modelsdk/widgets/templates/mendix-11.6/accessibilityhelper.json b/modelsdk/widgets/templates/mendix-11.6/accessibilityhelper.json new file mode 100644 index 00000000..e02ab201 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/accessibilityhelper.json @@ -0,0 +1,575 @@ +{ + "widgetId": "com.mendix.widget.web.accessibilityhelper.AccessibilityHelper", + "name": "Accessibility helper", + "version": "11.6.4", + "extractedFrom": "d6b6fc94-3653-4109-a73f-09944df7e718", + "type": { + "$ID": "5c3de2779d13478a826fed18d5e07708", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/accessibility-helper", + "ObjectType": { + "$ID": "dd4ee79e7559480d9684069e6af65eaf", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "9abe99286b744e8d93e49d770bf53166", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Target selector", + "Category": "General", + "Description": "Selector to find the first HTML element you want to target which must be a valid CSS selector like '.mx-name-texbox1 input'", + "IsDefault": false, + "PropertyKey": "targetSelector", + "ValueType": { + "$ID": "0e2976b38fc74508a3a638f223f54d15", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + }, + { + "$ID": "3bd8424210734732b930c34bb26bc344", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Content", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "content", + "ValueType": { + "$ID": "a70f929f68fb4c7f8f7c106ac7415ce7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "3f9062bcf3d048fd875f902b720e7610", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "HTML Attributes", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "attributesList", + "ValueType": { + "$ID": "8445209d45884c6ca2357bded63b442f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "c93ee83253034b3c8eab53ad487e3096", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "5ad7f3fa608e4f5880a438a61213b8b7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "HTML attribute", + "Category": "General", + "Description": "The HTML attribute to be set based on the condition. The following attributes are not allowed: 'class', 'style', 'widgetid', 'data-mendix-id'.", + "IsDefault": false, + "PropertyKey": "attribute", + "ValueType": { + "$ID": "ba5e723f2461458f87429f55644d275c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + }, + { + "$ID": "14d614c60f5148a4b4cc73510e4caadd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Source type", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "valueSourceType", + "ValueType": { + "$ID": "a358cb4620584b71823311e5f460cd3b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "text", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "58e0cd93c6e242149a31cccd3b2ca4ab", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "text", + "Caption": "Text" + }, + { + "$ID": "2b288e3d9c5d40b5b28977a146160013", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "d9569a7455e44927bedb3ed31fb993f6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Expression value", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "valueExpression", + "ValueType": { + "$ID": "39a7f02a43c34fc7b64927e3eb6668af", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "311f9b41a9894a928275bcb113940d6f", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "06e0b234e23d40e8a3ac09bf12000493", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Text value", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "valueText", + "ValueType": { + "$ID": "f33d608468c641c495a59897835d2aac", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "583d5460e20943d0ad9ea63d81e35258", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Condition", + "Category": "General", + "Description": "Condition to determine if the HTML attribute must be set or not", + "IsDefault": false, + "PropertyKey": "attributeCondition", + "ValueType": { + "$ID": "3521722cf0ea46e49be072a280e196a1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "293c423c2b534773b100bec2e591ecde", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Boolean" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Input Elements", + "StudioProCategory": "Input elements", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.accessibilityhelper.AccessibilityHelper", + "WidgetName": "Accessibility helper", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "4438c2a0d66845ee85276500f05451bd", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "4b20a3e358a74f4487cdba22c44505c9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9abe99286b744e8d93e49d770bf53166", + "Value": { + "$ID": "2f6ed0f0c168495cbfbe6973b2d647be", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d26eb73c9f53405db4a9c864ec55c3cf", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0e2976b38fc74508a3a638f223f54d15", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "885c2d5714e045779460a1e56a2c0d80", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3bd8424210734732b930c34bb26bc344", + "Value": { + "$ID": "696f1af8851d46528ad99615e41b53a5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "16d37d2505224052a6b89922158c7f88", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a70f929f68fb4c7f8f7c106ac7415ce7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d2f840d6ab8a41dda2fb3621364c2611", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3f9062bcf3d048fd875f902b720e7610", + "Value": { + "$ID": "0bdea5b240c94d35a6e3ff8c448b88ac", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7b7806c990224a1fa7033334dadb2cc5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8445209d45884c6ca2357bded63b442f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "dd4ee79e7559480d9684069e6af65eaf" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/accordion.json b/modelsdk/widgets/templates/mendix-11.6/accordion.json new file mode 100644 index 00000000..2164b4a9 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/accordion.json @@ -0,0 +1,1643 @@ +{ + "widgetId": "com.mendix.widget.web.accordion.Accordion", + "name": "Accordion", + "version": "11.6.4", + "extractedFrom": "d7e4c5c1-ace2-435f-840c-e52b5b2c86d2", + "type": { + "$ID": "9b829055d81f4432bfc058b314d01698", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/accordion", + "ObjectType": { + "$ID": "2bf34ced5aa64585bee73194224b2fd8", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "a9fe20a3479c4c2492c01a7d0116f807", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Enable advanced options", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "advancedMode", + "ValueType": { + "$ID": "a44b5dec4c054cf18cb8b6679516f095", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "8eb08fd0127a47728ed894189e2afd86", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Groups", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "groups", + "ValueType": { + "$ID": "20c082654b22478eb963f1e86ccf560c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "cd558af1126c4e1990ee32a37bf775b6", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "75940fa9e9c24764a5b907192325f86e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Header", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "headerRenderMode", + "ValueType": { + "$ID": "012f87736310460d8c4ae0ae688f77f7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "text", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "32d515a6e9e945f6addae6f5039a79a6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "text", + "Caption": "Text" + }, + { + "$ID": "b152efc11e364792b0d1e418397de934", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "custom", + "Caption": "Custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "d94078cf60934c8b9d3762f789b2667c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Text", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "headerText", + "ValueType": { + "$ID": "4a6357e0cbdb49d99faf006193d1d55d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "8a392dcf73e9410eb88821fa711a9d09", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Header" + }, + { + "$ID": "7c68574fd2154ae1b173c1b5bfb67ede", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Koptekst" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "509c024adbac4c918c748890a8674379", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Render mode", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "headerHeading", + "ValueType": { + "$ID": "8106d4f9eee04de58d1ec5684b514ff2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "headingThree", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "d1220234a2be4ecabcbae6a3acde284c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "headingOne", + "Caption": "Heading 1" + }, + { + "$ID": "6ca728e0d1ff4beebad078ccbfc67f12", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "headingTwo", + "Caption": "Heading 2" + }, + { + "$ID": "91da1cc906d04e0f9750f53f492c82ae", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "headingThree", + "Caption": "Heading 3" + }, + { + "$ID": "b64d97070a824b228421348fc3e74945", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "headingFour", + "Caption": "Heading 4" + }, + { + "$ID": "043d571e70844474a69c43a62545152e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "headingFive", + "Caption": "Heading 5" + }, + { + "$ID": "f6aec2605ae144d589fa35a2b0302da9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "headingSix", + "Caption": "Heading 6" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "65d967cbfe7f46dcbb229ba134ae6ba3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Header", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "headerContent", + "ValueType": { + "$ID": "ca9fd407a6ec44ebb4182863fc3bad02", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "d19cebf76ddc447da6ab777e930c9aae", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Content", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "content", + "ValueType": { + "$ID": "e40c72110a7041438356f419771d8346", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "f4849729831c4a7a881e0e3065013b3f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Visible", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "visible", + "ValueType": { + "$ID": "d8ab530ae1dd4687925a2306d5f1f37f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "1494174ff8b6425397b066f0992eeede", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Boolean" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "51507cb11a4446b38c1f347267071dc8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Dynamic class", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicClass", + "ValueType": { + "$ID": "3b841b8bf1ce46d0ae23a2db1cf5c274", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "e047c3d0a28f438392129637885a6aea", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "af77a3e64ed940a99eb312940ea04d14", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Load content", + "Category": "General", + "Description": "This property determines when the widgets should be rendered and data is fetched. The “Always” option will always load the widgets regardless whether the group is expanded. The “When expanded” option can reduce the initial (page) load time, but will increase the load time when expanding the group.", + "IsDefault": false, + "PropertyKey": "loadContent", + "ValueType": { + "$ID": "9d7fb194de604dd9b44fe8c00c21e53d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "always", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "75fcec702c544f6cada2aa490295d69c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "always", + "Caption": "Always" + }, + { + "$ID": "3f99fa6fb72241d28118e1f110efcbf7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "whenExpanded", + "Caption": "When expanded" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "71812e4f60e94d15b78dae49e1e6d63e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Start as", + "Category": "State", + "Description": "", + "IsDefault": false, + "PropertyKey": "initialCollapsedState", + "ValueType": { + "$ID": "acb113a51e1344789572144041f33fdc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "collapsed", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "667b7f8ccb0742919ecd037e86d2312e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expanded", + "Caption": "Expanded" + }, + { + "$ID": "8de17cd22f1f47349b8877d436c371d0", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "collapsed", + "Caption": "Collapsed" + }, + { + "$ID": "8685cf26cff3451cb54cb0c62cca7eb4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Dynamic" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "6407eec0890f49fbb12a1b18810a39dd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Start as collapsed", + "Category": "State", + "Description": "", + "IsDefault": false, + "PropertyKey": "initiallyCollapsed", + "ValueType": { + "$ID": "9b9bac64fef04e94825ae2c9562c02f3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "6211e801e12a4fb2ad02f03b2bd3b60f", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Boolean" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "8b01afe7bb3244689655ba76fb7721ed", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Collapsed", + "Category": "State", + "Description": "Determines whether the group is collapsed or expanded. The 'Start as' properties override the attribute value for the initial state.", + "IsDefault": false, + "PropertyKey": "collapsed", + "ValueType": { + "$ID": "d9ab3363e019431eb4f0e34818996b37", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Boolean" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "onToggleCollapsed", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "3f2e479194c8401094151d98adbfa072", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "State", + "Description": "Executes an action when the 'Collapsed' attribute value changes. Note: the 'Start as' properties can prevent execution of this action when the initial state changes.", + "IsDefault": false, + "PropertyKey": "onToggleCollapsed", + "ValueType": { + "$ID": "88e57b00c1274f56a2971c003d97f76c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "ef723b40e4674cb0a47d2a2bf377a810", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Collapsible", + "Category": "General::Behavior", + "Description": "", + "IsDefault": false, + "PropertyKey": "collapsible", + "ValueType": { + "$ID": "76c23c2ad61e4f738580f001e4907c53", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "171e668971c345ba8dd52d6af515d8e7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Expanded groups", + "Category": "General::Behavior", + "Description": "Allow a single group or multiple groups to be expanded at the same time.", + "IsDefault": false, + "PropertyKey": "expandBehavior", + "ValueType": { + "$ID": "604ded66e66c433dac83d2f74053beb2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "singleExpanded", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "b3dfac4f82324e5ba4af091d74110530", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "singleExpanded", + "Caption": "Single" + }, + { + "$ID": "15e1bbc52f544933ab154ef3b155e40b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "multipleExpanded", + "Caption": "Multiple" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "993ef05849cb4931b58e37b6b9613a97", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Animate", + "Category": "General::Behavior", + "Description": "", + "IsDefault": false, + "PropertyKey": "animate", + "ValueType": { + "$ID": "f517f2969b9b4e408580c9a77087ff9b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "2be7ddcc28174bea87be40d393876a67", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show icon", + "Category": "Visualization::Icon", + "Description": "", + "IsDefault": false, + "PropertyKey": "showIcon", + "ValueType": { + "$ID": "30099e4fb3884901ab204f02b7a1964e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "right", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "05c6e7f40f334d5591cc35bc8f86e5d4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "right", + "Caption": "Right" + }, + { + "$ID": "7699bb8048c2478284440e88c18a6907", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "left", + "Caption": "Left" + }, + { + "$ID": "fbebe833ec5b4a379a44035c0a1f14e7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "no", + "Caption": "No" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "4124118fc17f40f488f2a4348ae5e7f7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Icon", + "Category": "Visualization::Icon", + "Description": "", + "IsDefault": false, + "PropertyKey": "icon", + "ValueType": { + "$ID": "135d6dae1a5a49d6b57f20d3d9e1f666", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Icon" + } + }, + { + "$ID": "e667f977e59740699af8ba663fe783e5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Expand icon", + "Category": "Visualization::Icon", + "Description": "", + "IsDefault": false, + "PropertyKey": "expandIcon", + "ValueType": { + "$ID": "82a42970e63148a4b9f0ea30d7a00dcb", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Icon" + } + }, + { + "$ID": "3877992a51ed40c581cce1015fe275cf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Collapse icon", + "Category": "Visualization::Icon", + "Description": "", + "IsDefault": false, + "PropertyKey": "collapseIcon", + "ValueType": { + "$ID": "c33afcfe38e54bd8a82e8af529fd6538", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Icon" + } + }, + { + "$ID": "9f96f046d0c647dcb2b581d868608032", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Animate icon", + "Category": "Visualization::Icon", + "Description": "Animate the icon when the group is collapsing or expanding.", + "IsDefault": false, + "PropertyKey": "animateIcon", + "ValueType": { + "$ID": "9acf8e3196464786bfc7c055d5bd7497", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Structure", + "StudioProCategory": "Structure", + "SupportedPlatform": "Web", + "WidgetDescription": "Toggle the display of sections of content.", + "WidgetId": "com.mendix.widget.web.accordion.Accordion", + "WidgetName": "Accordion", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "c78a3f6d33804cb489462308a1d48363", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "ea6d01f4cedf441d9d0c6e56b6471f40", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a9fe20a3479c4c2492c01a7d0116f807", + "Value": { + "$ID": "ea08587d862a45438a6338673b3ed374", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6a25acd769604acaaf83784c526cbdf5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a44b5dec4c054cf18cb8b6679516f095", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b2ac3097de134b81ba5d252e786f431e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8eb08fd0127a47728ed894189e2afd86", + "Value": { + "$ID": "131de340a2cf4969bdbc5889459de568", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0d9bb2e0e7d64a988eb5ef48aa3df1b5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "20c082654b22478eb963f1e86ccf560c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "7d834a6cb4b94039a2b00de1b4339aa2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ef723b40e4674cb0a47d2a2bf377a810", + "Value": { + "$ID": "1caf5918ab9d4a0b8f88803f124f4f1f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3091d8a41c4e45ec98ecc643636bf565", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "76c23c2ad61e4f738580f001e4907c53", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a0eb4161f0f641798c7d339a2c726ae2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "171e668971c345ba8dd52d6af515d8e7", + "Value": { + "$ID": "47443d263e064782906f805755cfecb2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d29eb93b52614a43a4dea7441bef1b77", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "singleExpanded", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "604ded66e66c433dac83d2f74053beb2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a8e8d5fd18ae48d482019efe4c9e3ce7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "993ef05849cb4931b58e37b6b9613a97", + "Value": { + "$ID": "b4706b96a1774b5db0757df31d5d7ef9", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "03331c01a13a458294a14e6a226a7521", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f517f2969b9b4e408580c9a77087ff9b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c322671c3ced40679790e03059fa6c20", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2be7ddcc28174bea87be40d393876a67", + "Value": { + "$ID": "9e4f03a5aef640c6950a874177d725ce", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5044c9b6dadc448cb0ca07b9259a3681", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "right", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "30099e4fb3884901ab204f02b7a1964e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "405153c11e364dfd8afe842cc8222c6d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4124118fc17f40f488f2a4348ae5e7f7", + "Value": { + "$ID": "4162a808bef04984a7e3b7d7d0748022", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b3246d9cda074d27807e8ccd2b7b9bcc", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "135d6dae1a5a49d6b57f20d3d9e1f666", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "805fd08b6cd04ae098fe12c5c4aad0aa", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e667f977e59740699af8ba663fe783e5", + "Value": { + "$ID": "e2e316b7680b4a44843cc17db7ab1b1b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4d5fd1c9d3224a31b17c57c2718933f3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "82a42970e63148a4b9f0ea30d7a00dcb", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bfdc75bae7e9478ca885cc63922ad9bc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3877992a51ed40c581cce1015fe275cf", + "Value": { + "$ID": "856da36f92fc48e69c2c507502277f35", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5a8b8acc5d3a4531a32a665eeac37442", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c33afcfe38e54bd8a82e8af529fd6538", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e5e098a06b244badbd09c24367544352", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9f96f046d0c647dcb2b581d868608032", + "Value": { + "$ID": "02ad5d9e26cf4a91a5c9f0cb85a17582", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "dae94c4ac34e4dd3bc6eb46b83685fd5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9acf8e3196464786bfc7c055d5bd7497", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "2bf34ced5aa64585bee73194224b2fd8" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/areachart.json b/modelsdk/widgets/templates/mendix-11.6/areachart.json new file mode 100644 index 00000000..5cdfdc99 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/areachart.json @@ -0,0 +1,2955 @@ +{ + "widgetId": "com.mendix.widget.web.areachart.AreaChart", + "name": "Area chart", + "version": "11.6.4", + "extractedFrom": "fc805e44-3c87-436c-836a-0695e63d24d5", + "type": { + "$ID": "ab4d5280d82b4bc682e95ba8e23572d1", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "", + "ObjectType": { + "$ID": "042daa8b3fc84137888feed6bbb26049", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "fedae3140aac4f0c82c93119092d1aa8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Series", + "Category": "General::Data source", + "Description": "Add series and configure their properties", + "IsDefault": false, + "PropertyKey": "series", + "ValueType": { + "$ID": "cf44f20c7a3944a181bf17056ff74eda", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "5cea1433acad4d108414ed7566e70efb", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "a4bd4aa487c24e90bf61c1e935a9cd0d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Data set", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dataSet", + "ValueType": { + "$ID": "eefaea7cd80b43b681eff1457cc1d083", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "static", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "61f394ad083240cca1dcac2f7d0c6490", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "static", + "Caption": "Single series" + }, + { + "$ID": "e9867aebba214a3d93f61bcdb97fd530", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Multiple series" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "2f66685007334216a72e1e9f52ee1ec9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Data source", + "Category": "General", + "Description": "Data points for a single series.", + "IsDefault": false, + "PropertyKey": "staticDataSource", + "ValueType": { + "$ID": "ace704e42f9b41e6b41f98919885eb2b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "5ed251064e124f49a040098ba4a8047b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Data source", + "Category": "General", + "Description": "Data points for all series which will be divided into single series based on the Group by attribute value.", + "IsDefault": false, + "PropertyKey": "dynamicDataSource", + "ValueType": { + "$ID": "fa83898c1ddc4c58bb834c112d6d5758", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "8d7ac0615f3e42b6bd81c820b358132f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Group by", + "Category": "General", + "Description": "Data points within the same group form one series.", + "IsDefault": false, + "PropertyKey": "groupByAttribute", + "ValueType": { + "$ID": "602dcba63fa94622b34534b8b028259b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "String", + "Boolean", + "DateTime", + "Decimal", + "Enum", + "HashString", + "Integer", + "Long" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "dynamicDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "879ae0ff97fb4859a701a114a9846278", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Series name", + "Category": "General", + "Description": "The series name displayed in the legend.", + "IsDefault": false, + "PropertyKey": "staticName", + "ValueType": { + "$ID": "3c09ab70d0c64bddb82598f916a883a5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "3a6a695994744a47b55fd044e5e3ed46", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Series name", + "Category": "General", + "Description": "The series name displayed in the legend.", + "IsDefault": false, + "PropertyKey": "dynamicName", + "ValueType": { + "$ID": "339ba5d034164019aa39d21a72580c86", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "dynamicDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "5b31bc9abb554a1bab9d2c0c345809b6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "X axis attribute", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticXAttribute", + "ValueType": { + "$ID": "5a8e2737d1464be39c71091247e318f1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "String", + "Enum", + "DateTime", + "Decimal", + "Integer", + "Long", + "AutoNumber" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "staticDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "d669b4fb46164ad988b591341fc8229c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "X axis attribute", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicXAttribute", + "ValueType": { + "$ID": "86e749e601be4e1ab93651fdf120413e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "String", + "Enum", + "DateTime", + "Decimal", + "Integer", + "Long", + "AutoNumber" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "dynamicDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "6136b8bf95764eef9a175166d4e6cb0e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Y axis attribute", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticYAttribute", + "ValueType": { + "$ID": "7cb187c8c3e84194a056f10ffc038ee2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "String", + "Enum", + "DateTime", + "Decimal", + "Integer", + "Long", + "AutoNumber" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "staticDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "35e0a17b76c24b3191283cb557a90e3e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Y axis attribute", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicYAttribute", + "ValueType": { + "$ID": "b72c9aabe1174d978497234814718e15", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "String", + "Enum", + "DateTime", + "Decimal", + "Integer", + "Long", + "AutoNumber" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "dynamicDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "571814c218a34ad1b42e1fdb6af425f7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Aggregation function", + "Category": "General", + "Description": "Defines how data is aggregated when multiple Y values are available for a single X value", + "IsDefault": false, + "PropertyKey": "aggregationType", + "ValueType": { + "$ID": "df2dfba21c714ff49c5f30d117e2a05f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "none", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "40e7c39ca12f4d0ab67579f68e0177e5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "none", + "Caption": "None" + }, + { + "$ID": "833a077cb2de432ea9ac2f7227c4c08c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "count", + "Caption": "Count" + }, + { + "$ID": "8434e1ed67bc41c7beeb9bdfd9eb0cb0", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "sum", + "Caption": "Sum" + }, + { + "$ID": "4a21802b0a944e59b7844e1c072b728d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "avg", + "Caption": "Average" + }, + { + "$ID": "2ee8163106204e61b0e96c33b91524b7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "min", + "Caption": "Minimum" + }, + { + "$ID": "c187b7f8896844189731bbb237851186", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "max", + "Caption": "Maximum" + }, + { + "$ID": "dbcc89ceccaa4852ab6ed8ab8905d879", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "median", + "Caption": "Median" + }, + { + "$ID": "d2f20d5cc4e44197be4d752cfc99ecf0", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "mode", + "Caption": "Mode" + }, + { + "$ID": "cf247af9731445608a212ccb36601b49", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "first", + "Caption": "First" + }, + { + "$ID": "55742a4ca6774e039f4ab6a0fd82c646", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "last", + "Caption": "Last" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "5155e4350e85492bb69318de5d766310", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip hover text", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticTooltipHoverText", + "ValueType": { + "$ID": "47c5dfffd5ee4bf19d8bf1cf61287318", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "staticDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "a6920725d2534918a4314bba2199ac6d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip hover text", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicTooltipHoverText", + "ValueType": { + "$ID": "a9716315fb0e49d9beed3c9fa740b2f4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "dynamicDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "faae07e613b44c8b82cc205a0cea04dc", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Interpolation", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "interpolation", + "ValueType": { + "$ID": "ce80a39d87aa475cbf814dc643555224", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "linear", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "d44ac31245be47288c485f8f3897084a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "linear", + "Caption": "Linear" + }, + { + "$ID": "904c71db2d914e60bfc167a8b1849cee", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "spline", + "Caption": "Curved" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "41cc26b947c843ceb604bddf48c7343d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Line style", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "lineStyle", + "ValueType": { + "$ID": "192c0397df9e4747909d84686bc1c4c5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "line", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "f8526ce38bd041bf963b8cbfdc9a116b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "line", + "Caption": "Line" + }, + { + "$ID": "38535bd9cb034c868f15f611af747d8c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "lineWithMarkers", + "Caption": "Line with markers" + }, + { + "$ID": "ce26d05e416c466dbb70d0c72ed3041f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "custom", + "Caption": "Custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "d23be6a811fb4f488a8bcc74efa13095", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Line color", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticLineColor", + "ValueType": { + "$ID": "6ac13cbf8cb54ec081ebc7c670bc16c9", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "staticDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "941458377dc241e6ab081cd0a98731bd", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "e156f1bacf364f74994d1502a7df06a3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Line color", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicLineColor", + "ValueType": { + "$ID": "74e4904f6ed243e59798ae82ac10de78", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "dynamicDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "939ada0836e64121af0d04f9aceb5ea1", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "98cd727eeeac469890f108d714d760bf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Marker color", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticMarkerColor", + "ValueType": { + "$ID": "fe4703dd26db44edb969d623e08a1e1b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "staticDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "b921cf8881c640c79c3baafb2f0a9667", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "b94d53c6eca947978252e122c1e6d56d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Marker color", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicMarkerColor", + "ValueType": { + "$ID": "cd3f8c06052947f39325fa7089aa4eab", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "dynamicDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "43a6b311e65c4df58b2037ba9b806bf4", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "01318629ea34460a9c1f9cb4b8c77e90", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Area fill color", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticFillColor", + "ValueType": { + "$ID": "7e539f3902eb4bbfbc68e99d7e53e0db", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "staticDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "90288070052240f0a0fd10a699cea5db", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "3692299be0f84548826d8527103ca308", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Area fill color", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicFillColor", + "ValueType": { + "$ID": "fc33bef18de04bb48eb3aee39409e126", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "dynamicDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "a160790f8d6846aabe739386d44a0c5b", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "9dd98b2525b84538aefc592db751e71e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click action", + "Category": "Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticOnClickAction", + "ValueType": { + "$ID": "678c084838524e1b82b9710c334eeb40", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "staticDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "4b227e4811904f66a686e07b53fa7534", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click action", + "Category": "Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicOnClickAction", + "ValueType": { + "$ID": "4b00fda13576461ead53d8a9f918033f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "dynamicDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "bd68452195c7481d82b1edd80e4ea219", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom series options", + "Category": "Advanced", + "Description": "", + "IsDefault": false, + "PropertyKey": "customSeriesOptions", + "ValueType": { + "$ID": "90c602035b0d48b6b3eb14f60dcca788", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": true, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "10dd3cb022b14a5fbca85e92a449c2db", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Enable advanced options", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "enableAdvancedOptions", + "ValueType": { + "$ID": "1715cc01641f4372889ba3dbaa7d75f3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "7f4487f2d5eb4b7fa1bbafa30b3da770", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show playground slot", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "showPlaygroundSlot", + "ValueType": { + "$ID": "d7ca3668c6374353b4fdd45e689e25f6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "df01fb30535d4117b3101670afb04356", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Playground slot", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "playground", + "ValueType": { + "$ID": "fde93bf882004e179fbe9deb1bddb743", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "90fdcbfd8bc84bb792881c9487c0832a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "X axis label", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "xAxisLabel", + "ValueType": { + "$ID": "d0176fa0f7854e7db7e853876c4c5a63", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "19dfa60ef1d44c9ca808da9ec9ae02d3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Y axis label", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "yAxisLabel", + "ValueType": { + "$ID": "1e24e31f1de442d9ba308a5826d73613", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "dffa95d3eb2d468bb5f0e94e90817065", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show legend", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "showLegend", + "ValueType": { + "$ID": "61bcb80b560147bb93e365657197cffe", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "ad533e816cd4469e89d995ecefca848f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Grid lines", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "gridLines", + "ValueType": { + "$ID": "cf118a4bd6f8494cb4e3c207b20d29b0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "none", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "39463fb030b14b0890ecda06773308c4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "none", + "Caption": "None" + }, + { + "$ID": "067fc0ecfa234a47bef15ca657c0c232", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "horizontal", + "Caption": "Horizontal" + }, + { + "$ID": "9d7dc52a596b4c76971841ac94fd9519", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "vertical", + "Caption": "Vertical" + }, + { + "$ID": "c01f12f9701a44e0b0c1e480438997f4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "both", + "Caption": "Both" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "0d416fd63d9d4e7a86b3f3e22046de56", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Visibility", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "61a935d77e544db9801627eaf44c0a02", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "24a9fb62fcea42278c9df925f9bf22e7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Name", + "ValueType": { + "$ID": "997e1dec54634424afdbef91b2fe3837", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "da3af3b1823740d2b26f59fc1bc967b0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "TabIndex", + "ValueType": { + "$ID": "a314f8fd263c4697be3895f2ee3e162f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "d8cdac67ab3b458e9a37dc82fdc7c30a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Width unit", + "Category": "Dimensions::Dimensions", + "Description": "Percentage: portion of parent size. Pixels: absolute amount of pixels.", + "IsDefault": false, + "PropertyKey": "widthUnit", + "ValueType": { + "$ID": "0f687b57d2664cdc89d66d8d15eb168e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "percentage", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "16397fc4e1104fb4b8c6250a298f6a25", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentage", + "Caption": "Percentage" + }, + { + "$ID": "695c47d908f84e65b4f544779a8934ce", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "pixels", + "Caption": "Pixels" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "5443235e93614619a5fcac8a84185b9d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Width", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "width", + "ValueType": { + "$ID": "217d8baf7a4e4f83bf973f6ccacf95cc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "70bd0d33a9e74c36bf12292c295166bb", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height unit", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "heightUnit", + "ValueType": { + "$ID": "a8417a2956bb4247b1d6a8609cf856db", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "percentageOfWidth", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "1506ef7bb5474a07b53d638eb24da920", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentageOfWidth", + "Caption": "Percentage of width" + }, + { + "$ID": "46b3ab8394834a3da28196dfda1fd228", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "pixels", + "Caption": "Pixels" + }, + { + "$ID": "27908550accb4c518eef3ea029a90518", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentageOfParent", + "Caption": "Percentage of parent" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "c8be0326e0cd4172b68b0e8521093a20", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "height", + "ValueType": { + "$ID": "f96cfbeaca6d419891e0d19af12b4f16", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "75", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "ebfad7c5e2014b03856118defb896a46", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Enable theme folder config loading", + "Category": "Advanced::Advanced", + "Description": "", + "IsDefault": false, + "PropertyKey": "enableThemeConfig", + "ValueType": { + "$ID": "55dc3d0b9eea4fada252f837662b1fc7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "149963d338614d498337045df37250fc", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom layout", + "Category": "Advanced::Advanced", + "Description": "", + "IsDefault": false, + "PropertyKey": "customLayout", + "ValueType": { + "$ID": "cad8dcf6d87f4cde8848455b239b1db7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": true, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + }, + { + "$ID": "554b34b35355425f904dba7559a4d734", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom configurations", + "Category": "Advanced::Advanced", + "Description": "", + "IsDefault": false, + "PropertyKey": "customConfigurations", + "ValueType": { + "$ID": "2338a487dc594f1caa8c7b1505cd0733", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": true, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Charts", + "StudioProCategory": "Charts", + "SupportedPlatform": "Web", + "WidgetDescription": "Create an area chart", + "WidgetId": "com.mendix.widget.web.areachart.AreaChart", + "WidgetName": "Area chart", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "c90426f7a2ce40cfbef83ab818395488", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "a9ebb83e0e334c188b0824ce847f6aa2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "fedae3140aac4f0c82c93119092d1aa8", + "Value": { + "$ID": "8ece006822d641dc89fba968f58e3be9", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "92524cbb96354b14a0edd00b7f5f8708", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cf44f20c7a3944a181bf17056ff74eda", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c6e617f8330f4310977d918d6c75644d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "10dd3cb022b14a5fbca85e92a449c2db", + "Value": { + "$ID": "8a7869dc5e9e49baa2e9dd14f80c2f71", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ef37d6b28b2842ae82e631b04adf66d1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1715cc01641f4372889ba3dbaa7d75f3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b69ec8bef8a94735b7a0b416b5db9cdc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7f4487f2d5eb4b7fa1bbafa30b3da770", + "Value": { + "$ID": "46a2bc885fe746f581411c6cf56780cf", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "59e237222f8845d8a3eaccd93a616451", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d7ca3668c6374353b4fdd45e689e25f6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f76451a4008d4d0aaf2e5c9ca685a008", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "df01fb30535d4117b3101670afb04356", + "Value": { + "$ID": "e597d50a36ac450c8dcbe47328a797be", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9f2eb0e4153049309f3da755a7806b61", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fde93bf882004e179fbe9deb1bddb743", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2816d75aab6e4a3e996c0905a97f8be0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "90fdcbfd8bc84bb792881c9487c0832a", + "Value": { + "$ID": "1d67eb2eabdd44e0b61953dcfd280f54", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1896a289d8144681a580c179e20fecc6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "d5b702ebc99a497db72e271c471f3ffa", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "88946a9b63304ff0b7981124a371b840", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "c94143fe86fb46febf0355436d88069e", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "d0176fa0f7854e7db7e853876c4c5a63", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0451022872cd43888af6e409918861f9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "19dfa60ef1d44c9ca808da9ec9ae02d3", + "Value": { + "$ID": "011819fb1b2d4dad9e388ee831359c6c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7ae79af30f5847dda02a001caad1a772", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "81b4566045f24392afdac6e492a30748", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "6fc3a62c0f064636b0ba1599fbad963f", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "fec14758a14246189ecf98ab9742e17a", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "1e24e31f1de442d9ba308a5826d73613", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "139f2d99550447e0ad4670d58271ce94", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "dffa95d3eb2d468bb5f0e94e90817065", + "Value": { + "$ID": "26717a29961e4edd80c76af5f10ec91d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4313dd812f3047b3ace3399c7f699187", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "61bcb80b560147bb93e365657197cffe", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1de0c7861307459d84e187c350aaed82", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ad533e816cd4469e89d995ecefca848f", + "Value": { + "$ID": "56d91fe3775b44b5927720ca18ab32e0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "391235c6f6ef49ee8aebe05e073cb05b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "none", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cf118a4bd6f8494cb4e3c207b20d29b0", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f19e5c9396f947aaa713ffdc9682176d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d8cdac67ab3b458e9a37dc82fdc7c30a", + "Value": { + "$ID": "9f78747affe64e889e446929c7ff1bb8", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0d51c38d12b24571947f8888ddafb14f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "percentage", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0f687b57d2664cdc89d66d8d15eb168e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9c77c9fbf2694642984768a7b4d20fee", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5443235e93614619a5fcac8a84185b9d", + "Value": { + "$ID": "87c1e023f64645c1959c604d222f13df", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c65f2655c1e54b349d0de217c537a17a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "217d8baf7a4e4f83bf973f6ccacf95cc", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "27300dc4840b42e3a2f82a2dc6621a55", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "70bd0d33a9e74c36bf12292c295166bb", + "Value": { + "$ID": "ebadb1609676489e9a6cb8319388079e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1bbbd8f212274b38bf4bf1d37adfcc66", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "percentageOfWidth", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a8417a2956bb4247b1d6a8609cf856db", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e96d0262d9c84f1e871bf812c5c9e998", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c8be0326e0cd4172b68b0e8521093a20", + "Value": { + "$ID": "6a458576677644638c86a88220f5f88a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "53d32b8fdd8049a9b369d9a5d00e5abe", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "75", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f96cfbeaca6d419891e0d19af12b4f16", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "7724ce0f2c3049579a5950a3a3319bf6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ebfad7c5e2014b03856118defb896a46", + "Value": { + "$ID": "5d65e20eff954595bbd35856edef432a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "11600880dc5f4144850a33c2fc3e8e99", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "55dc3d0b9eea4fada252f837662b1fc7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9006fe0941d54787adff5b7b658178d6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "149963d338614d498337045df37250fc", + "Value": { + "$ID": "f1cba8f0a145433a882ae3da51e09cef", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b61f2e6a05de4aeea39c5afcab9a81f7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cad8dcf6d87f4cde8848455b239b1db7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "38344dead414494eb6e937f4e92609eb", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "554b34b35355425f904dba7559a4d734", + "Value": { + "$ID": "c562556ec98e420e8836d99e51401d81", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0e9a2aa87f5145a88614c20910c5c1fe", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2338a487dc594f1caa8c7b1505cd0733", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "042daa8b3fc84137888feed6bbb26049" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/badge.json b/modelsdk/widgets/templates/mendix-11.6/badge.json new file mode 100644 index 00000000..ffad45d1 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/badge.json @@ -0,0 +1,499 @@ +{ + "widgetId": "com.mendix.widget.custom.badge.Badge", + "name": "Badge", + "version": "11.6.4", + "extractedFrom": "83cca78d-22db-42ca-b240-96bab87b5ea6", + "type": { + "$ID": "9e274f783a54436bad1999dd95a9f280", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/badge", + "ObjectType": { + "$ID": "1384bec123534199b6b0b2ea035a3179", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "555856bea9d141c7aadaf23df5eb80e1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Type", + "Category": "General::General", + "Description": "Render it as either a badge or a color label", + "IsDefault": false, + "PropertyKey": "type", + "ValueType": { + "$ID": "d54f16a9d6f54bd8b451e06a038e255c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "badge", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "5cf56a2cf8a24cb6979ddb96c879dea9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "badge", + "Caption": "Badge" + }, + { + "$ID": "866da99cec274b4fb63f1cb4295a30ce", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "label", + "Caption": "Label" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "6b20222dc8b941ddb107017f6a2bc754", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "value", + "ValueType": { + "$ID": "0a6295c8d8c1412d9095030900e26c43", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "80a64a52993c4d2ba148a8432cb87730", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Badge" + }, + { + "$ID": "f6899968c8db440294eb62f820d8c54d", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Badge" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "e65c75abcd714e5d88a74763e9dee6f7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClick", + "ValueType": { + "$ID": "0d3b0d6a38f0447f9269e9c550e5ae5b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "0c671ff171fd4d16b6821397fcae867f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Visibility", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "df23e99e1c0d4edca524d37d36f592bb", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "f34490489f28491494f916246e5530b9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Name", + "ValueType": { + "$ID": "8ebcf1b818a24d0e84c5d0be34ae0669", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "d59047a500454ca5a68dc0afe9589465", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "TabIndex", + "ValueType": { + "$ID": "42127cc7083640dcbb24f1fd1b8b252e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Display", + "StudioProCategory": "Display", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.custom.badge.Badge", + "WidgetName": "Badge", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "b191758d8ae74dc5be25ef1e513857af", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "5575e33caa0f4dc691f9a36f850681ed", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "555856bea9d141c7aadaf23df5eb80e1", + "Value": { + "$ID": "e39bcff97aaa43e8a078c07fddaba388", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "68b2569f32444e6b94060b7dfea64452", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "badge", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d54f16a9d6f54bd8b451e06a038e255c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "72b1ec8f57bc4fa7997a74dced005023", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6b20222dc8b941ddb107017f6a2bc754", + "Value": { + "$ID": "d83bd4805716412ead67c45d28a6a976", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "fd02c1b48e094a09bb0d41779a8592dd", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "235dffc822594a1f87de620cba444de7", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "882b5aab868845c28636d4209263cfe3", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "ea91ce0f03bd4a1797d0be4c226e7c4b", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "85c46a6a2fbb4b289c16dd07643875b6", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Badge" + }, + { + "$ID": "21ffe4bd98c4413ab3e23c48e2b38082", + "$Type": "Texts$Translation", + "LanguageCode": "nl_NL", + "Text": "Badge" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "0a6295c8d8c1412d9095030900e26c43", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "38e37b0f97664122820f2716c5edac92", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e65c75abcd714e5d88a74763e9dee6f7", + "Value": { + "$ID": "a2a9801284f54255a12603db83e5eab5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e45b19238900441896af6f6f41fc1da6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0d3b0d6a38f0447f9269e9c550e5ae5b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "1384bec123534199b6b0b2ea035a3179" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/badgebutton.json b/modelsdk/widgets/templates/mendix-11.6/badgebutton.json new file mode 100644 index 00000000..e95d1d3f --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/badgebutton.json @@ -0,0 +1,507 @@ +{ + "widgetId": "com.mendix.widget.custom.badgebutton.BadgeButton", + "name": "Badge button", + "version": "11.6.4", + "extractedFrom": "d7f00fd7-1453-4eb8-ac89-0dcd71afafec", + "type": { + "$ID": "831b978fab204e66875cabc5353f9312", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/badge-button", + "ObjectType": { + "$ID": "759eac27ace6401abdb5b40368866420", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "eae62503898249b7a69d806c129bb870", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "label", + "ValueType": { + "$ID": "0aa399c331e940bc8f4ad40fb03af4bb", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "8e4035abba434c43a4f69044e493c9aa", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Button" + }, + { + "$ID": "52446bf832d8440b8b3049e29709ed71", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Knop" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "855e856443ba4b4e93b8d2b7c4d0c040", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value", + "Category": "General::Badge", + "Description": "", + "IsDefault": false, + "PropertyKey": "value", + "ValueType": { + "$ID": "91e1594dd5324ffd8059c63212cddf7e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "8a8a7ef4dbf64e509361bc3f22692cab", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Visibility", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "883fdaed681542ba998cb4cea46b26fc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "58f30ec22b8549a097dc2821bd5b7027", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClickEvent", + "ValueType": { + "$ID": "598dcf467ad742eab225dc7dded7d701", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "b0fc71c80db842d59f4f763e2b9b7061", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Name", + "ValueType": { + "$ID": "6c03b03dad20496fb61032bfafba222a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "bcad1f889c184dc5a2b36423aa9f6223", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "TabIndex", + "ValueType": { + "$ID": "fb58e400ce6249c190cfeec46f3e214c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Buttons", + "StudioProCategory": "Buttons", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.custom.badgebutton.BadgeButton", + "WidgetName": "Badge button", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "0075f56f65c445119c969b92bebebfe3", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "dc6f1bc49b0a4050918c70c8af872848", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "eae62503898249b7a69d806c129bb870", + "Value": { + "$ID": "5bee9ae3cf894b6eaf2913a6594330d8", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2903bc0c851940d1a800ab599c66129c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "e3b39d0a093b4cb5a826ab7b892f6880", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "db22afe546be4cf6882fe99b570fe4b1", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "5d57ddde262a4497a180af3dadc507d6", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "8c3897cb2f414139a642edb711c3a144", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Button" + }, + { + "$ID": "1ac06c1b86054a3db0ea1c61629b83c6", + "$Type": "Texts$Translation", + "LanguageCode": "nl_NL", + "Text": "Knop" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "0aa399c331e940bc8f4ad40fb03af4bb", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "509a8b3b9a614ee0bf60bab6ca72a23f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "855e856443ba4b4e93b8d2b7c4d0c040", + "Value": { + "$ID": "e5294180853045b49ad901ed22124404", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a18939cf12c749a5be7d9e3002912c12", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "636016df8b9f4d15b4f2d04095e7b8a0", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "1b9ee95feb56478b9320a53eb0e173c4", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "070c286b6a2846b98452439a37911821", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "91e1594dd5324ffd8059c63212cddf7e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "dcf17972ca554ac9b4941be6e4c41972", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "58f30ec22b8549a097dc2821bd5b7027", + "Value": { + "$ID": "dda00f61c34344e8b916aaf7e677acb9", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6d996a12fec04d01875f9b4da31546da", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "598dcf467ad742eab225dc7dded7d701", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "759eac27ace6401abdb5b40368866420" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/barcodescanner.json b/modelsdk/widgets/templates/mendix-11.6/barcodescanner.json new file mode 100644 index 00000000..08ec2683 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/barcodescanner.json @@ -0,0 +1,1166 @@ +{ + "widgetId": "com.mendix.widget.web.barcodescanner.BarcodeScanner", + "name": "Barcode Scanner", + "version": "11.6.4", + "extractedFrom": "2b7fdb72-6eb1-454d-a802-5aba764b77aa", + "type": { + "$ID": "0da65cbde2944091ac27bbd4ed8407f9", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/barcode-scanner", + "ObjectType": { + "$ID": "0dfe60a187464140b0d34505b18d3cfd", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "3a0f0fb474db4bddb20891d47de45932", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Scanned result", + "Category": "General::General", + "Description": "The String attribute used to store the result of the scanned barcode.", + "IsDefault": false, + "PropertyKey": "datasource", + "ValueType": { + "$ID": "952eed9ce6c04716b07e8eedebf84d7c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "String" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "75a181b291ab421989dc541b1577bb15", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show barcode mask", + "Category": "General::General", + "Description": "Apply a mask to camera view, as a specific target area for the barcode.", + "IsDefault": false, + "PropertyKey": "showMask", + "ValueType": { + "$ID": "086f6704d5524de7b49bdd02247b93b6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "7da17500358a43f5a932236173fbbd03", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Use all barcode formats", + "Category": "General::General", + "Description": "Scan for all available barcode formats", + "IsDefault": false, + "PropertyKey": "useAllFormats", + "ValueType": { + "$ID": "d535e99996024a6b9c7a8c688637079d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "099018a4ba2a44119b10880c75cd2404", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Enabled barcode formats", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "barcodeFormats", + "ValueType": { + "$ID": "3837318200964fd69cb4fd1666591d43", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "c42e7d5225084b4e931b5cc13203590a", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "674396265d274d6ca685f9b4c3c70709", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Barcode format", + "Category": "Object list group", + "Description": "Barcode format which should be recognized by the scanner", + "IsDefault": false, + "PropertyKey": "barcodeFormat", + "ValueType": { + "$ID": "d9fdb39a4e1142628d2bf4a04abed200", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "AZTEC", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "96ba85a7621e42d1b46640c9f699edd7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "AZTEC", + "Caption": "Aztec" + }, + { + "$ID": "e37627e8b669466785603ea70d712ec5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "CODE_39", + "Caption": "Code 39" + }, + { + "$ID": "f2b8479601d84db09374b2658e6fc426", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "CODE_128", + "Caption": "Code 128" + }, + { + "$ID": "aeefdcb0fd8046329339adf0c21470be", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "DATA_MATRIX", + "Caption": "Data Matrix" + }, + { + "$ID": "b2edeaa9e4ba4c37a09ff25f7e3a0786", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "EAN_8", + "Caption": "EAN-8" + }, + { + "$ID": "52dae29c49984e1dac71b40e32e1a24e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "EAN_13", + "Caption": "EAN-13" + }, + { + "$ID": "f15401313339418fa8a45f49f8bc911d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "ITF", + "Caption": "ITF" + }, + { + "$ID": "42c7d087b51340bb9d9372240bc4f3b2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "PDF_417", + "Caption": "PDF 417" + }, + { + "$ID": "3dc754d497274822847a18130dd5dcf6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "QR_CODE", + "Caption": "QR Code" + }, + { + "$ID": "390bd3b225e346da8d986aec4d46b6b4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "RSS_14", + "Caption": "RSS-14" + }, + { + "$ID": "b75a33ab8bfb400988a8a001aae3cf5e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "UPC_A", + "Caption": "UPC-A" + }, + { + "$ID": "a13092698b924e7ea8e04455f604bec4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "UPC_E", + "Caption": "UPC-E" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "22299ce7299d4fd9a480d6b3979336eb", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On detect action", + "Category": "General::Events", + "Description": "Action to trigger when the barcode has been successfully detected.", + "IsDefault": false, + "PropertyKey": "onDetect", + "ValueType": { + "$ID": "192e8584113a4fad828ff361b85edd33", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "21ae491b404b4a21921d0044bcac6f2b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Name", + "ValueType": { + "$ID": "6a34b2c7727143fa8a4399c966070aa5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "85228b50c51b4dc68eace21d461fd7a1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "811a93307e044714a7461b76ea06810a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "1bce78118ca041539fbbea0c3d5a18fd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Width unit", + "Category": "Dimensions::Dimensions", + "Description": "Percentage: portion of parent size. Pixels: absolute amount of pixels.", + "IsDefault": false, + "PropertyKey": "widthUnit", + "ValueType": { + "$ID": "63e15d123c784fd2b367b3ab68863fb1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "percentage", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "3a79fb42dd304dd6be050dacea0de0d5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentage", + "Caption": "Percentage" + }, + { + "$ID": "36537ec83bef43009429fd7fcc10f164", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "pixels", + "Caption": "Pixels" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "dadbf80510c941e1851f14396a78f611", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Width", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "width", + "ValueType": { + "$ID": "051313616e564aa58390712dd00d6738", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "278e6f88ca5346dd883fcbd810fe8bd6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height unit", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "heightUnit", + "ValueType": { + "$ID": "2e634983564149b0b32a8a3f4f700528", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "percentageOfWidth", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "ab858fb381f04c2cb4a3632699552248", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentageOfWidth", + "Caption": "Percentage of width" + }, + { + "$ID": "9b75da9d924442d0843d24a4b1025d98", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "pixels", + "Caption": "Pixels" + }, + { + "$ID": "4707ef93256046b8a2776b385ecf7111", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentageOfParent", + "Caption": "Percentage of parent" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "aac7b8dcc985401e84342fde5eb1b9bf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "height", + "ValueType": { + "$ID": "e79701ff57fe4747b903c4696d6333d3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "75", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "21d8dde252ac497b9244c7191f8a14fc", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Detection logic", + "Category": "Advanced", + "Description": "Choose the detection logic to use for barcode scanning.", + "IsDefault": false, + "PropertyKey": "detectionLogic", + "ValueType": { + "$ID": "30992c2695654242b6b27bfc63e30f00", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "native", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "1fe4fb05f8fb4ab083601270e4efa373", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "zxing", + "Caption": "ZXing" + }, + { + "$ID": "0e09eaca0dc043529fb1f959eac8b03a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "native", + "Caption": "BarcodeDetector API (experimental fast scan, fallback to ZXing)" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Images, Videos & Files", + "StudioProCategory": "Images, videos & files", + "SupportedPlatform": "Web", + "WidgetDescription": "The widget lets you scan a barcode", + "WidgetId": "com.mendix.widget.web.barcodescanner.BarcodeScanner", + "WidgetName": "Barcode Scanner", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "0c784a92e130406d8a5bd4e8ffe44dbb", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "1382914ee022455496db32d018f7bcb2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3a0f0fb474db4bddb20891d47de45932", + "Value": { + "$ID": "ea29b7a948a84d5395f22d0c58401cbc", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "036a2844205f4c0e8a4ce6fa81272202", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "952eed9ce6c04716b07e8eedebf84d7c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5a9082f43aba4c5d80e06c5821bc74d5", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "75a181b291ab421989dc541b1577bb15", + "Value": { + "$ID": "b9314efa2c1d475f89190b95d8549aad", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "57577c3b02b948e3a208fc70ff663d4e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "086f6704d5524de7b49bdd02247b93b6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ad0e645da06e4009b7d6b10a8b36b67a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7da17500358a43f5a932236173fbbd03", + "Value": { + "$ID": "fbcb5acd5caa48d88c064ffb7b5d2919", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a4e3a19f058a431ab56de832b6ad850a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d535e99996024a6b9c7a8c688637079d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f9c1e1b8afc54913bc80b4e7ef97efa7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "099018a4ba2a44119b10880c75cd2404", + "Value": { + "$ID": "073fd52946c845cb8f61ffe8ca0f7c4d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "df21916323cc4ab79d7ce408ba6908af", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "3837318200964fd69cb4fd1666591d43", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "96fc8d3c2f1f416886e7dc3aa37959f7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "22299ce7299d4fd9a480d6b3979336eb", + "Value": { + "$ID": "04fddda5df8e46e09665deeff97a1bf1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "262f3bedfe49470b96a068eb2ea327e2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "192e8584113a4fad828ff361b85edd33", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "dd8f4f3f0577422898289d86a7834615", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1bce78118ca041539fbbea0c3d5a18fd", + "Value": { + "$ID": "e26d837e29c14307acc071704d0bf24b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e07fa120047f4ddaaaec746ef977e7af", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "percentage", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "63e15d123c784fd2b367b3ab68863fb1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e08c9f8395e74c969af83f6c7083d3c2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "dadbf80510c941e1851f14396a78f611", + "Value": { + "$ID": "117ab989793c4d72932255b80f678aa7", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a2f9ab26b39c4e3589bb62a09b81ad7c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "051313616e564aa58390712dd00d6738", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d8ced11d1f9d4fd496d41fc02e38aa3b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "278e6f88ca5346dd883fcbd810fe8bd6", + "Value": { + "$ID": "f04160097e174436ba15e6629a79e8af", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "94e636cf112640d9abb51fce2af72bf3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "percentageOfWidth", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2e634983564149b0b32a8a3f4f700528", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cc53d695a8904ed8b1b95a6183e81987", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "aac7b8dcc985401e84342fde5eb1b9bf", + "Value": { + "$ID": "9ad8289f95ca48b7964b6c8723221804", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9149d1b0e45a4d6c91ba6cd4675d11a3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "75", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e79701ff57fe4747b903c4696d6333d3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e39c83e58cf042a8b9ff7b2ceec4ffd0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "21d8dde252ac497b9244c7191f8a14fc", + "Value": { + "$ID": "33c4e8b1357f42c4b01b024e1609d3df", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "243f6da117e74a9189dd8d63e5603ed9", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "native", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "30992c2695654242b6b27bfc63e30f00", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "0dfe60a187464140b0d34505b18d3cfd" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/combobox.json b/modelsdk/widgets/templates/mendix-11.6/combobox.json new file mode 100644 index 00000000..ca53666a --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/combobox.json @@ -0,0 +1,5410 @@ +{ + "extractedFrom": "968455d7-ee59-4396-820e-36fce9fd6358", + "name": "Combo box", + "object": { + "$ID": "b3cdeae5a3655341a7c5ebaa0ac6599f", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "b2e87966bd48344c9badf1edbaaa2794", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ebdb8977fa676f4c93770a000a841c3e", + "Value": { + "$ID": "d9ecaec8452e3242afd8fa04381db665", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "647eef7893056943adfaf96f9aa5766c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "context", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9a7bf3a36633e54e982ee855cd2522ba", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "94219d7a1a11394890e418304df179aa", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3a700dbcde88fd4c939a9469219d4ec7", + "Value": { + "$ID": "a3e56b44ca460b43ae24976476e8e84d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9afd24019d8f4544943281d5af8de38a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "enumeration", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "16be1ecef1ca954c8da01718b54ae4f3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "13354b9d5c71c44fa35a20c7bc72d499", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6859faf5d24d73418c42c6a06a24e363", + "Value": { + "$ID": "7e6482f9e43e51419712778947b68c30", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9662a69440797746b96ecc358ee3c9fe", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "db04d6fe119b384e813459a49a6771f4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4b45256270432d4d96838a8722f35c60", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1ccf1e1afe8cbd48b229a3387e64c676", + "Value": { + "$ID": "993433426d50d84da7f68f506ba8a074", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "47ffd6d1d610c04c93d09fca860ac95f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "705691798877ec40bdcc29ad3305869b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5a0f0fc12a20714b8b3ecc3d3a572afd", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "35b1bba4a871fe43877ed4af12e559a9", + "Value": { + "$ID": "651109bd0552914f82ff72dae2d9f1c0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f41c97958ba9f943961a98a5abf599c2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "451347db5de73d47b3f409d6e4f92211", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "56b391ec20d3c241af9ced7a5f2bd971", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "77bbf42e69e55b4b801c92de4570d3e8", + "Value": { + "$ID": "06ac9b9f970aaa4093e35e1a535ddcbf", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ebfa1a307f3ef64db3b23ddc30c44914", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "Single", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8252a4f2071b5747a8be695e447336a4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "db55fb8509aa704c83daaa5575201f85", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6a821785e324b7408b99b4e657dbd766", + "Value": { + "$ID": "a3edc71f6887ad4ba5b86e4a511847ea", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0fe0492386fe3a43b6d23b28e384359c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "attribute", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2861bfa52733ca4a946b6bb7efa2d485", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d833575b193c8a48a317e1da5a4952c7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f1ea1b7f4945804e9312cec11528510c", + "Value": { + "$ID": "fffa04af2d494249996ace66bfc27e98", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2bead08d7ce34f4ea638683c9eb4e53e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "attribute", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e88da4cd9156cd43a6df3074eb6af266", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6d5413918222bb45b279e8f72b9dbcf5", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1a6565101fd37641a897b2ce271ad5a9", + "Value": { + "$ID": "7845e02a3e6a0048ba31a8753bce82bc", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8375828fd4c2ff4c9b7bc7e1d76eacf1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2ae8c29159298e45b8038087b9dd287a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "14c542439a2b274eb5e4c3a056471475", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "29b66c5748445b44a18b02b375c1935e", + "Value": { + "$ID": "98b0b6b0fe7be745ac62fc48d825022a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5c5143f535f9644cbf74fa835524716b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "96c75f53ac5a7744b1a3a64a7af0f6dc", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "632a25ea3102fe4790941d5f8b6642bc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "44ce38419f68804b837cd2a0e05dd2c8", + "Value": { + "$ID": "9277c34c35e44947968fe8cd11677a7c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5f69917205fbb34da9f963d1078a13c5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "02f1d12c54b99747a61fa3f734a0e292", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "211fdc94b0e98245944956409b8c7ebe", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c32f86958c06a248b0a9be01510a990b", + "Value": { + "$ID": "e41686ba62c49f41888b5bf6c8bf4752", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "23954ea05982bc40b16f7cd6aeadc7e6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "77ce4fc394f31a4f925f58cf62824e0b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f5fd157cdc886a489c8db5ddf44f8b62", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b469ae48b6f9a0439f0f1ffd042281a8", + "Value": { + "$ID": "b3d54304685b2747b9cb6827d41a4d67", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "bcb9e1e6934cfe419345c7a142c73c25", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c9662b103765c34cab5db6b4c84931e0", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d3190e4f2e8e904cbd84d61c82e33bbf", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f76a4179fddfb343be5617d0a7f2934a", + "Value": { + "$ID": "e0770b2db82e4643a2bd161bc91b611e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2ed23a46faf23f4481c6665619a59de0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "54ccad24632a5f4c8cc0edf86b89b688", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2c0910ee24278e499e4328636d61df30", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "30eb075f4e92c043b02fa377edcda215", + "Value": { + "$ID": "f21e42b4ad5f0146886d8439552b6b4a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a7b1760acee6974fb73f97ba2f16a605", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f0cf2b927b65534ca0db3f9ced94f7c0", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d4e783d0dcb3b945810961d2e66f6832", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "0c0c0f0f89d28b4083169c09a73794c3", + "Value": { + "$ID": "bfbb508011567540833120413a9980d6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d6de26d32534d545bf8631337170271a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "432d9200f1d66e40b31d631203747668", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5dd52eeb197a524a9cac671199ff449b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4875c33c02bc134986596b8f20a48e6b", + "Value": { + "$ID": "aabbdece7ea06847ab8455e94056467f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1353d8229b72334a965c8874412f3d76", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "07d986c806213f4bb3bc2e30574de8e9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1ad9f2aeb2f87f4d88940cabd869b76d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7d8625908e99854b919441215eddf761", + "Value": { + "$ID": "43e0b5108ca12c48ba7ae5a6da54ac13", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "882b3011f2f99f4a9d38930836051a6b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ecdb3c9edb5df2468379c069dc4a4478", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "45b538c661211b40b9937f8b1720a750", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9be4b8dcede6ef4881cb21c31b9552ca", + "Value": { + "$ID": "cc54046ad6cbd947bbdbe3981f561e79", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5f70df8c7cbfcc4588f5a688c4e5ecd1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "e98994de1e481e4a8b4c693d1ae7748e", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "7ad09797dc62514bb2926cc34d2e09f4", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "6aa3f73b54accc4c922c074340ee44a6", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "9a1a8cf27777804ea51daad312309f67", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e6575f892bf20b4b90fb46ea7b7258e1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "765073c56291f44da66b8c343b9d3345", + "Value": { + "$ID": "7d973a605e4f8441ab6c68ae9e6e2b76", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8d98fc177b6f614e80ef60f792e3660b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "00281a013aabaa4ab4f95afd6031ac9a", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "963d325bbfa5cf4d947c2870e6a6333a", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "e295ed69d9300a4db2af31fb2fc26184", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "2fb5c0e28b404e41bd8a2b0f1aad11b4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6753c08112b7af4b8c743a880715913f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9c880e53f9cb104ea73a9f722e189c4b", + "Value": { + "$ID": "39d0860d7d816f43bbf6f4c2ff1f6762", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "434cffcbc9b8f843830b72abf4603de1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5eb0f01a6e1c4a4b938e52fd296c5560", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e5890db8fe124548975e4b0330c99743", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7853c63531ca024c9f79cd12f0b8b490", + "Value": { + "$ID": "74271b731eb8d54ea910af33ac10adba", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6a3b49a84e3721428ae2e756e6444957", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "no", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "212639bf53c77f4a92587b0eda86ede1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "991157655866da4dbf61aa8f5c05ba96", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f5fbc454b67bf64194f082ee68265be1", + "Value": { + "$ID": "f8f527f4b34515488661bc5afc3c75df", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "19f790af5598c941bad9c0b31c2cdb74", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "853f075c0868c847b6969227fe174ae3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "71576f3904f28f4599f1cf323cb19308", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "22171cc8615a4146b02bff76485c9f6c", + "Value": { + "$ID": "e4d7127bb5fad24ca342f1f6a34080a6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6fffe15734ad8c4bbc08b24a8694872f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "no", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "581f36c110e94f42844f8fa5185a3a1e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0d0337f6c1447e4b94773ab49f8727d6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "157b2b11af980b448ccbef6daccc6c69", + "Value": { + "$ID": "a86e2beac0b7a842b7906f231a811c7b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2fa5808a415b52408f42db73a519b4a0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "dd58ced95f5bb24b89b5261f1f99c4a5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c011b919eb24b142b0b1089de18b0a7f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7db58106aa73c949b2e4122f739508b7", + "Value": { + "$ID": "57609c7c9b202741965b34a10548e085", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "fd93305a30f02240aaf58b58ab6c832a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "no", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4c93e4a83f9ec7458918253eece17c63", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "dc08d738feaef844bdd555b6b13419c4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "08df6c993024c34ea4f132571af3d08b", + "Value": { + "$ID": "8ddeec60b7c4694e8df7919453b58d46", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8604ceb30c58184894e3a5486e2ccce5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "56f96f73a686804fa47aa85bc8805a69", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "75e7f413ac3d43499bc87d127d336e8a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6e1577a6f8e61d4b92be2b2aefb761d7", + "Value": { + "$ID": "8555e7ec0386fb46a934bed62fccd94a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "cf61a781bcdf314caaeff7840d34fa28", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "aa344bf32f46b24087c58fa69995d74f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c9676a6d89ff6c4dbfebb6c8a9b0c3c0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9fbc4f08310f0f42ae0621dc378623aa", + "Value": { + "$ID": "757e4eef4d7e754dbc877845c2f90cfe", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "115461136385aa49b54fe702436a504a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "checkbox", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cd337c2a7137ff4c8ddc4519de872f95", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "49df32d6b9cca6439ba06ddfd2056736", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ae718dd591ee1544b5e0e4a33a1ab227", + "Value": { + "$ID": "089fa28e973585479ae9fa58761fa446", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6d818c9119b80e4fb268aaf0b312b56a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "text", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b90f4b188223d141984192c99bb665c8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "74fe0037a6bffc46b0fd421575f7ca80", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4014ac9c85e45542b81c833ef18ad41c", + "Value": { + "$ID": "1aa8e23625309f4085aab8cccaf0e5bc", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "86c56a114698dc429d3758b4f38d2cdc", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0ba36bcc7dc4994a99f793ca1928b4ac", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "534f2ebc0d4e53428c3bdd6a21f6d566", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a3da969951dd454d8f1fab8946f0119b", + "Value": { + "$ID": "ab9271ee5ed0114da9afff4b134f28e1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "59cd539d4f43374aa528f6f7dc675e54", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8112ca78e65be34e95322565eb6dbb8a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0c309d449a6b4643a3c3e8fce645ea1b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5d3c49ade6739b49b40ae9480741780a", + "Value": { + "$ID": "ca2aec3b5b3d74478cdc8efed0b060fc", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9f32a5974a7f7e4badf48b9c6a9ebcc6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "default", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ad1beed94272bc41a6550f58205f5057", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "82314863b5fc2346813d00d1e67dca79", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7944b17f5098ad42a241cb3353e4c8a3", + "Value": { + "$ID": "29545a45d20e8443ab0b9b01f57fe00d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2047cb087ab5834ca869fe73ded67d17", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "false", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "00449946afd2ef4ba55a490241662308", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "fb291550e4e7dc48aa02cf8996faeba7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "63a0790a75adf94bbfaceef266d5df28", + "Value": { + "$ID": "7dcc0947612e834dbf12a0c4817f4987", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a30cee4e685d984ab3d6d6f3fee23030", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "bordered", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d1e5534a0fd98645a772dc5d76f4760e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "393b90214cec7e44a18d4ab6edda3209", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3b6d1202656aa54a9ffa75b3034f22ce", + "Value": { + "$ID": "7dbac0ba05a1f74dad6439bf39a983e6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7485a0a494200e46907d6b19749d52e9", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c6cb6132950a194a84d13239e474f06f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "07ebee1fe9433449962291f62859a44e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "97ab7fae2f882e4d9e1950b8cdfae8c4", + "Value": { + "$ID": "68d9958d95c9a746848891ec69f86001", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f79007b243ac8643881b532eba96c48d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f523f58983078c4091afe7fc32e27961", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "542de07ae60e5744aff5387ccf40c0ab", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2ab261a68ab09348bcada368b83f4b39", + "Value": { + "$ID": "0eadc124638e95449e0a0e4cf34d4262", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5b2df78ad66891479bd3e9c755bfb7a2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "af446cc9443bea4094293974cd36d839", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0f87109ec1bda547bbe8efefd9658a66", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8bd5f251d1428c4c873d94f319165625", + "Value": { + "$ID": "cbf05346ef8fb6498ffc597bef4ac3c7", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6a7b85c6ddb667419b614de00fbb0f4d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5e8418e37ded4543b3a8199ffb521abd", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cfb5d7dc2a068d4eaed608ae8fc97063", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "67b0738981cd1f4f8e491139051d54b3", + "Value": { + "$ID": "55690173c8a4a5458f6c55b0e01655ff", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a081a65695af994ba46265a06e29b237", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7e5739e798376d4c86eed936b266ed39", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c193e27e31d8914ca8aeb49b537293da", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a6027fcd725e8f42b5c590086e728a5b", + "Value": { + "$ID": "e1d11b8d590d4a4b814bccbd763b840d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "764fa387fda8fb4ea9c60e120f4f1d0c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "200", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "47ae75cd9de2634884803cb343903898", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "dcc38f7c81641c488058dab545302082", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5e7d02bba94de44ab25aeea2b7a7aa33", + "Value": { + "$ID": "f6cba12a8358534ab791c41c701624f5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3d3c5405ebe951459fcacb8bdc142c2f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "false", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8a18c0b26d438c429aa8f45ffe8277b9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "76af1415ea0bd14590178fc8a2225792", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2e08fec5251f1b4a94d1126d4aef8272", + "Value": { + "$ID": "7fc471c13086c94281999401a68da047", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ebdc85bab75eb84bb6b98fd07b0d6b6d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "45cb5a70ad081a4dbfd813c7c1706070", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "3279bb7c5e7b304b94482ede0b0717a5", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "bbe945be2fa4ee449416ee617a0efc45", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "258abb723ff74644acc0aff8461344f9", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Combo box" + }, + { + "$ID": "674e31060f9d794aaa91a3930967c408", + "$Type": "Texts$Translation", + "LanguageCode": "nl_NL", + "Text": "Keuzelijst" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "7575d915eebcd548a421b28cbec8a42e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d29d31299a797d4e8ed66a7aff1b17d6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "fd649302c940ad4dbb735540f55327b0", + "Value": { + "$ID": "d0eccadde0d72d468c05715406e24513", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "780f4383813f2c4d85fd2be4b31d710a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "b54b5d8888c66049970b4374896060e3", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "ff398af77d3e984b95277229dae73dc3", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "3e9a676d52f90b4581c62e05b29cbcd0", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "ef7df3f3b6b2ea4283236455567051d4", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Clear selection" + }, + { + "$ID": "7a13c9042d1a3946b6babbd3cf9960ef", + "$Type": "Texts$Translation", + "LanguageCode": "nl_NL", + "Text": "Selectie wissen" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "e79a1bf184e49e42bcf51c6d9cbd0bb5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "3741576be8a7ca409e4aab9a0c32192a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "676df25e9797bd4aab0ed5312fdb79ca", + "Value": { + "$ID": "3e360a1d2d77d249a2aaa13155eac278", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "507b28fe6d854647acee8b65e5932a0d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "c4a3804a4da6ae409a235004afc70bf5", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "b3bad0c7ce0bb2438655b7536d995584", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "0c1dcae452128945bd901abf8a4bddcc", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "22dc7d1f056709428ec0f52debcc8bf0", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Remove value" + }, + { + "$ID": "328feaf64d011e4eac1e14b6e66dd5be", + "$Type": "Texts$Translation", + "LanguageCode": "nl_NL", + "Text": "Waarde verwijderen" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "28880ab7066f944f94032f63f841a077", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ed48c2a1cc244242a0c9cc0380fa6c9f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f52ec34faac0844fbe4da1c8c4494e2c", + "Value": { + "$ID": "03330ce8c9b9414a9d8103074a4d3a5d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7846b2f52269a043a010ab97d4dfee05", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "554972467de5c04da93f109ec7834e0b", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "bb5904ead5a63f43b1f52018d8ed51b1", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "a914a048d701af41864ad401cbafc3e1", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "77a2b4c04830d74ab72955a7b2078066", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Selected value:" + }, + { + "$ID": "61a68c4262589e418e13a52e0ee7df75", + "$Type": "Texts$Translation", + "LanguageCode": "nl_NL", + "Text": "Geselecteerde waarde:" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "df7ea805010cda49b9e2941ef535d1e3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "07b6ac1b94d21c40bf4cbe6e73378b9a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c270e4909878a2438470d751710d9c96", + "Value": { + "$ID": "4615ffc31c21874db7632c09ea563aa1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "cc30792314e07749a391f5225e6801ab", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "a0a584fe6e722848bd000ee1bceac4ed", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "03992960ba1ffc4b9800e408a15033f6", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "fd8cab313c299744902f7ba766117ea6", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "17f99ae4404e4a4bb9e69c2d6ef91f7c", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Number of options available:" + }, + { + "$ID": "a3e76c7d53be36478dd562e884640692", + "$Type": "Texts$Translation", + "LanguageCode": "nl_NL", + "Text": "Aantal beschikbare opties:" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "ba5118b8cf9c24469fa15c5c799fb248", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9e3783f3ce43964d88b3210ac783acde", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cebab06ee976534d9f0919854228405b", + "Value": { + "$ID": "6e3d43e3f143ca4dacbef70925ed924f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c123c86c962f7240abb32fe614daea8f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "5b49ad3a2f12134caed934c437861323", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "a9f7f4ee7f66594c83fd76619890cf2d", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "686c25c14610e446ba97072ae8ce25a9", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "40183076603f3d47a23f8092167da209", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Use up and down arrow keys to navigate. Press Enter or Space Bar keys to select." + }, + { + "$ID": "f8770f8ee5cf314e84f1ad616531eee4", + "$Type": "Texts$Translation", + "LanguageCode": "nl_NL", + "Text": "Gebruik de pijltjestoetsen (omhoog en omlaag) om te navigeren. Druk op Enter of de spatiebalk om de waarde te selecteren." + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "ff461bf2ce8243458762df0ab2cdd07d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "55d8ef0ceee3024cad4e88e488b77d9f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "855c1f90d0be0049ab3732a7efc8300d", + "Value": { + "$ID": "51776c728b8ce248aa82fcf0f7733fdb", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "efa6a40760fe2440986b01e241154212", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "40116ac12039a647858827cd041e93e8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f3d1e3e3f60f404f8c4ed31d74483a29", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "82552d3d012af841a276a1796715fada", + "Value": { + "$ID": "97c17e522304b04a8635b8a212b64e53", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f57001511684e647a910708f0e715bb5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "spinner", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "97b54b737b151e4ba1fd590a3e558018", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "76232f0e3dc5a94b889d4b9a86c02072", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e2996d42d90a15478592b7e310fd223c", + "Value": { + "$ID": "661126b16779fc4ea69325958f7f65ce", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d587f319645b524c88f2116dd5f74d38", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "none", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "61818e1393afd7479aea231e986a91e9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8b943345a8523c4b83d957d53d8969b0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "05f9a77d8f1ca64b873edaa0a71b7719", + "Value": { + "$ID": "8cbe7094002a2d4a996a1944abd01a61", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4c8a711d4470db4bb34ac697727c0081", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "contains", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6392dfadf2bc7f43a0aa8005f0c10677", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "08c9dc368f0ad74e9a50b59cdaec6be7" + }, + "type": { + "$ID": "cf4462deb736aa488c71c9bf59f056c2", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/combobox", + "ObjectType": { + "$ID": "08c9dc368f0ad74e9a50b59cdaec6be7", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "ebdb8977fa676f4c93770a000a841c3e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Source", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "source", + "ValueType": { + "$ID": "9a7bf3a36633e54e982ee855cd2522ba", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "context", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "61c5df5309837a42b3a3d2a9c21b8c5a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Context", + "_Key": "context" + }, + { + "$ID": "e73fac88aadaf940825c92b77b87f66f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Database", + "_Key": "database" + }, + { + "$ID": "bb500e542265484ba37919b3a5a2d123", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Static", + "_Key": "static" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "3a700dbcde88fd4c939a9469219d4ec7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Type", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceType", + "ValueType": { + "$ID": "16be1ecef1ca954c8da01718b54ae4f3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "association", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "1c95cc3ac0f05e458b7a7f2eb483c761", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Association", + "_Key": "association" + }, + { + "$ID": "9ab9b3bc0da4e546a9020d75e6372e60", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Enumeration", + "_Key": "enumeration" + }, + { + "$ID": "c639598388236a4eacacbb25a86713a7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Boolean", + "_Key": "boolean" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "6859faf5d24d73418c42c6a06a24e363", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "attributeEnumeration", + "ValueType": { + "$ID": "db04d6fe119b384e813459a49a6771f4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "Enum" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": true, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "1ccf1e1afe8cbd48b229a3387e64c676", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "attributeBoolean", + "ValueType": { + "$ID": "705691798877ec40bdcc29ad3305869b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "Boolean" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": true, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "35b1bba4a871fe43877ed4af12e559a9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selectable objects", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceDatabaseDataSource", + "ValueType": { + "$ID": "451347db5de73d47b3f409d6e4f92211", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "77bbf42e69e55b4b801c92de4570d3e8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selection type", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceDatabaseItemSelection", + "ValueType": { + "$ID": "8252a4f2071b5747a8be695e447336a4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "optionsSourceDatabaseDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "onChangeDatabaseEvent", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1, + "Single", + "Multi" + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Selection" + } + }, + { + "$ID": "6a821785e324b7408b99b4e657dbd766", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption type", + "Category": "General::Caption", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceAssociationCaptionType", + "ValueType": { + "$ID": "2861bfa52733ca4a946b6bb7efa2d485", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "attribute", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "0c373dfdfe40964e903245b6dd714988", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Attribute", + "_Key": "attribute" + }, + { + "$ID": "20bf898065a3374a88a49eae81024fba", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Expression", + "_Key": "expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "f1ea1b7f4945804e9312cec11528510c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption type", + "Category": "General::Caption", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceDatabaseCaptionType", + "ValueType": { + "$ID": "e88da4cd9156cd43a6df3074eb6af266", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "attribute", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "54e1425f551a524ba12006c5b8ff9697", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Attribute", + "_Key": "attribute" + }, + { + "$ID": "45c1f2b382a56c4580110f24c17d464e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Expression", + "_Key": "expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "1a6565101fd37641a897b2ce271ad5a9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General::Caption", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceAssociationCaptionAttribute", + "ValueType": { + "$ID": "2ae8c29159298e45b8038087b9dd287a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "optionsSourceAssociationDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "29b66c5748445b44a18b02b375c1935e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General::Caption", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceDatabaseCaptionAttribute", + "ValueType": { + "$ID": "96c75f53ac5a7744b1a3a64a7af0f6dc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "optionsSourceDatabaseDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "44ce38419f68804b837cd2a0e05dd2c8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General::Caption", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceAssociationCaptionExpression", + "ValueType": { + "$ID": "02f1d12c54b99747a61fa3f734a0e292", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "optionsSourceAssociationDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "8ff7b243831c3e4a825bdd6e6f6fbf6e", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "c32f86958c06a248b0a9be01510a990b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General::Caption", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceDatabaseCaptionExpression", + "ValueType": { + "$ID": "77ce4fc394f31a4f925f58cf62824e0b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "optionsSourceDatabaseDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "dabce8df0f65e7448d67082c300c88c4", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "b469ae48b6f9a0439f0f1ffd042281a8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value", + "Category": "General::Store value", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceDatabaseValueAttribute", + "ValueType": { + "$ID": "c9662b103765c34cab5db6b4c84931e0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String", + "Integer", + "Long", + "Enum" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "optionsSourceDatabaseDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "f76a4179fddfb343be5617d0a7f2934a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Target attribute", + "Category": "General::Store value", + "Description": "", + "IsDefault": false, + "PropertyKey": "databaseAttributeString", + "ValueType": { + "$ID": "54ccad24632a5f4c8cc0edf86b89b688", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String", + "Integer", + "Long", + "Enum" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": true, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "30eb075f4e92c043b02fa377edcda215", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Entity", + "Category": "General::Attribute", + "Description": "", + "IsDefault": false, + "PropertyKey": "attributeAssociation", + "ValueType": { + "$ID": "f0cf2b927b65534ca0db3f9ced94f7c0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1, + "Reference", + "ReferenceSet" + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "optionsSourceAssociationDataSource", + "SelectionTypes": [ + 1 + ], + "SetLabel": true, + "Translations": [ + 2 + ], + "Type": "Association" + } + }, + { + "$ID": "0c0c0f0f89d28b4083169c09a73794c3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selectable objects", + "Category": "General::Attribute", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceAssociationDataSource", + "ValueType": { + "$ID": "432d9200f1d66e40b31d631203747668", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "4875c33c02bc134986596b8f20a48e6b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "General::Values", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticAttribute", + "ValueType": { + "$ID": "07d986c806213f4bb3bc2e30574de8e9", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String", + "Enum", + "Integer", + "Long", + "Boolean", + "DateTime", + "Decimal" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": true, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "7d8625908e99854b919441215eddf761", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Values", + "Category": "General::Values", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceStaticDataSource", + "ValueType": { + "$ID": "ecdb3c9edb5df2468379c069dc4a4478", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "9f79cca50c8bec4ba301ddb78a368eb1", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "6ec9fe094e78044fb85c9e9bbe1ba977", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value", + "Category": "Static values", + "Description": "Value to be set", + "IsDefault": false, + "PropertyKey": "staticDataSourceValue", + "ValueType": { + "$ID": "5a268f8358e8b14788a2e0bc297f7e8b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "ea8aeaa0205a8542be1908b1e8a17834", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "../staticAttribute", + "EntityProperty": "", + "IsList": false, + "Type": "None" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "4e69d9ec793da6408660c789bf1701cd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom content", + "Category": "Static values", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticDataSourceCustomContent", + "ValueType": { + "$ID": "83be2a185b03204fa41d208824018895", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "4036ddabeb7d124a9a58f964ae50a7fd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "Static values", + "Description": "Caption to be shown", + "IsDefault": false, + "PropertyKey": "staticDataSourceCaption", + "ValueType": { + "$ID": "0ab777602545844eb2164b6ed1c8ca6d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "9be4b8dcede6ef4881cb21c31b9552ca", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Placeholder text", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "emptyOptionText", + "ValueType": { + "$ID": "9a1a8cf27777804ea51daad312309f67", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "765073c56291f44da66b8c343b9d3345", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "No options text", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "noOptionsText", + "ValueType": { + "$ID": "2fb5c0e28b404e41bd8a2b0f1aad11b4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "9c880e53f9cb104ea73a9f722e189c4b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Clearable", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "clearable", + "ValueType": { + "$ID": "5eb0f01a6e1c4a4b938e52fd296c5560", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "7853c63531ca024c9f79cd12f0b8b490", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom content", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceAssociationCustomContentType", + "ValueType": { + "$ID": "212639bf53c77f4a92587b0eda86ede1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "no", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "d6644cf5038de04fbcb36d79f91e5ff9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Yes", + "_Key": "yes" + }, + { + "$ID": "37e706e5c64b924cb7d08e83206674fd", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "List items only", + "_Key": "listItem" + }, + { + "$ID": "46d279d2766f5d40adf0448622935412", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "No", + "_Key": "no" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "f5fbc454b67bf64194f082ee68265be1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom content", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceAssociationCustomContent", + "ValueType": { + "$ID": "853f075c0868c847b6969227fe174ae3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "optionsSourceAssociationDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "22171cc8615a4146b02bff76485c9f6c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom content", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceDatabaseCustomContentType", + "ValueType": { + "$ID": "581f36c110e94f42844f8fa5185a3a1e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "no", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "3e3cbe7a737b2a4bb09d64b87d72d125", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Yes", + "_Key": "yes" + }, + { + "$ID": "c3a1349973096949a56b3a6ef61e1efc", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "List items only", + "_Key": "listItem" + }, + { + "$ID": "65d662dcc162d04490813d9ceda4402a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "No", + "_Key": "no" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "157b2b11af980b448ccbef6daccc6c69", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom content", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "optionsSourceDatabaseCustomContent", + "ValueType": { + "$ID": "dd58ced95f5bb24b89b5261f1f99c4a5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "optionsSourceDatabaseDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "7db58106aa73c949b2e4122f739508b7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom content", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticDataSourceCustomContentType", + "ValueType": { + "$ID": "4c93e4a83f9ec7458918253eece17c63", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "no", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "918e2eee29021e41b1e3e68985f776e8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Yes", + "_Key": "yes" + }, + { + "$ID": "a2452c960020be40a2c4646776bcdde3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "List items only", + "_Key": "listItem" + }, + { + "$ID": "dee2282009c1dd4dae9fdfa30a3f2d13", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "No", + "_Key": "no" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "08df6c993024c34ea4f132571af3d08b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show footer", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "showFooter", + "ValueType": { + "$ID": "56f96f73a686804fa47aa85bc8805a69", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "6e1577a6f8e61d4b92be2b2aefb761d7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Footer content", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "menuFooterContent", + "ValueType": { + "$ID": "aa344bf32f46b24087c58fa69995d74f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "9fbc4f08310f0f42ae0621dc378623aa", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selection method", + "Category": "General::Multiple-selection (reference set)", + "Description": "", + "IsDefault": false, + "PropertyKey": "selectionMethod", + "ValueType": { + "$ID": "cd337c2a7137ff4c8ddc4519de872f95", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "checkbox", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "1040608374c00f4ea26d67c676317b9c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Checkbox", + "_Key": "checkbox" + }, + { + "$ID": "1fbe0713818dc34a902eade5c1c7d9c6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Row click", + "_Key": "rowclick" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "ae718dd591ee1544b5e0e4a33a1ab227", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show selected items as", + "Category": "General::Multiple-selection (reference set)", + "Description": "", + "IsDefault": false, + "PropertyKey": "selectedItemsStyle", + "ValueType": { + "$ID": "b90f4b188223d141984192c99bb665c8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "text", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "6e8a735fa4259d43903889dd5ee292d0", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Text", + "_Key": "text" + }, + { + "$ID": "fd43997e53cfd342abcc24a5a858a778", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Labels", + "_Key": "boxes" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "4014ac9c85e45542b81c833ef18ad41c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show select all", + "Category": "General::Multiple-selection (reference set)", + "Description": "Add a button to select/deselect all options.", + "IsDefault": false, + "PropertyKey": "selectAllButton", + "ValueType": { + "$ID": "0ba36bcc7dc4994a99f793ca1928b4ac", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "a3da969951dd454d8f1fab8946f0119b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption for select all", + "Category": "General::Multiple-selection (reference set)", + "Description": "", + "IsDefault": false, + "PropertyKey": "selectAllButtonCaption", + "ValueType": { + "$ID": "8112ca78e65be34e95322565eb6dbb8a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "7192dd8a99ed5f4bb034448bf89b3121", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Select all" + }, + { + "$ID": "84007303e22b9f468b4878c8d9016f86", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Selecteer alles" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "11c64a0f050b8c409376556168b77180", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Label", + "Description": "", + "IsDefault": false, + "PropertyKey": "Label", + "ValueType": { + "$ID": "9eca86d41babdc429c6d44534a53bc36", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "2feda4a3f96ba14b88c8c03aab9d920a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Conditional visibility", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "7aec338f6be0c04ebb67eae82d43e81b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "cfd4419dadda6743a430aa744aa65f33", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Editability", + "Description": "", + "IsDefault": false, + "PropertyKey": "Editability", + "ValueType": { + "$ID": "687e2d98f955934da224e22c57328593", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "5d3c49ade6739b49b40ae9480741780a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Editable", + "Category": "General::Editability", + "Description": "", + "IsDefault": false, + "PropertyKey": "customEditability", + "ValueType": { + "$ID": "ad1beed94272bc41a6550f58205f5057", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "default", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "c7536a1c244ded4eb6fa4ae717654f8f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Default", + "_Key": "default" + }, + { + "$ID": "9bbb32b4d01a4b4ebabac458759ecc1c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Never", + "_Key": "never" + }, + { + "$ID": "14da36c3128bdd45b9b81b6778975e7e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Conditionally", + "_Key": "conditionally" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "7944b17f5098ad42a241cb3353e4c8a3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Condition", + "Category": "General::Editability", + "Description": "", + "IsDefault": false, + "PropertyKey": "customEditabilityExpression", + "ValueType": { + "$ID": "00449946afd2ef4ba55a490241662308", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "e3072b94a0331e418dae13020e21d308", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Boolean" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "63a0790a75adf94bbfaceef266d5df28", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Read-only style", + "Category": "General::Editability", + "Description": "How the combo box will appear in read-only mode.", + "IsDefault": false, + "PropertyKey": "readOnlyStyle", + "ValueType": { + "$ID": "d1e5534a0fd98645a772dc5d76f4760e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "text", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "599db46eb570374ebdaf69a98a77fafb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Control", + "_Key": "bordered" + }, + { + "$ID": "394892caeeb2634f9faaae387706bd8f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Content only", + "_Key": "text" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "3b6d1202656aa54a9ffa75b3034f22ce", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onChangeEvent", + "ValueType": { + "$ID": "c6cb6132950a194a84d13239e474f06f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "97ab7fae2f882e4d9e1950b8cdfae8c4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onChangeDatabaseEvent", + "ValueType": { + "$ID": "f523f58983078c4091afe7fc32e27961", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "2ab261a68ab09348bcada368b83f4b39", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On enter", + "Category": "Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onEnterEvent", + "ValueType": { + "$ID": "af446cc9443bea4094293974cd36d839", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "8bd5f251d1428c4c873d94f319165625", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On leave", + "Category": "Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onLeaveEvent", + "ValueType": { + "$ID": "5e8418e37ded4543b3a8199ffb521abd", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "67b0738981cd1f4f8e491139051d54b3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On filter input change", + "Category": "Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onChangeFilterInputEvent", + "ValueType": { + "$ID": "7e5739e798376d4c86eed936b266ed39", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2, + { + "$ID": "bfff80690077f149ab2e2aa6acea77c0", + "$Type": "CustomWidgets$WidgetActionVariable", + "Caption": "Filter Input", + "Key": "filterInput", + "Type": "String" + } + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "a6027fcd725e8f42b5c590086e728a5b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Debounce interval", + "Category": "Events", + "Description": "The debounce interval for each filter input change event triggered in milliseconds.", + "IsDefault": false, + "PropertyKey": "filterInputDebounceInterval", + "ValueType": { + "$ID": "47ae75cd9de2634884803cb343903898", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "200", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "5e7d02bba94de44ab25aeea2b7a7aa33", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Aria required", + "Category": "Accessibility::Accessibility", + "Description": "", + "IsDefault": false, + "PropertyKey": "ariaRequired", + "ValueType": { + "$ID": "8a18c0b26d438c429aa8f45ffe8277b9", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "56ab5e3fdc01e143a730528de1c85e7e", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Boolean" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "2e08fec5251f1b4a94d1126d4aef8272", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Aria label", + "Category": "Accessibility::Aria labels", + "Description": "Used to describe the combo box.", + "IsDefault": false, + "PropertyKey": "ariaLabel", + "ValueType": { + "$ID": "7575d915eebcd548a421b28cbec8a42e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "ae77c6b1c4af4c44b1e2b1ddcc4eb7c2", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Combo box" + }, + { + "$ID": "2dd542ecba19734381495309c7a16ebe", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Keuzelijst" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "fd649302c940ad4dbb735540f55327b0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Clear selection button", + "Category": "Accessibility::Aria labels", + "Description": "Used to clear all selected values.", + "IsDefault": false, + "PropertyKey": "clearButtonAriaLabel", + "ValueType": { + "$ID": "e79a1bf184e49e42bcf51c6d9cbd0bb5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "f800b52cd2fad946aaf519dbecda865a", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Clear selection" + }, + { + "$ID": "4b10ebd9d10f8b4a95f90a1599f3c72f", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Selectie wissen" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "676df25e9797bd4aab0ed5312fdb79ca", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Remove value button", + "Category": "Accessibility::Aria labels", + "Description": "Used to remove individual selected values when using labels with multi-selection.", + "IsDefault": false, + "PropertyKey": "removeValueAriaLabel", + "ValueType": { + "$ID": "28880ab7066f944f94032f63f841a077", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "207192768cb6bf40b262f7c1922e5f2d", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Remove value" + }, + { + "$ID": "66f08a586e210c4f9d91bca3e97804f4", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Waarde verwijderen" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "f52ec34faac0844fbe4da1c8c4494e2c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selected value", + "Category": "Accessibility::Accessibility status message ", + "Description": "Output example: \"Selected value: Avocado, Apple, Banana.\"", + "IsDefault": false, + "PropertyKey": "a11ySelectedValue", + "ValueType": { + "$ID": "df7ea805010cda49b9e2941ef535d1e3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "b97fa525a1685e4c8f0a94a865bc166d", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Selected value:" + }, + { + "$ID": "42e9763258aa8e4891f242557945910f", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Geselecteerde waarde:" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "c270e4909878a2438470d751710d9c96", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Options available", + "Category": "Accessibility::Accessibility status message ", + "Description": "Output example: \"Number of options available: 1\"", + "IsDefault": false, + "PropertyKey": "a11yOptionsAvailable", + "ValueType": { + "$ID": "ba5118b8cf9c24469fa15c5c799fb248", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "f571910a13792149b27b2540551afe26", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Number of options available:" + }, + { + "$ID": "1118b0516b2f394c84e2672d14149382", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Aantal beschikbare opties:" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "cebab06ee976534d9f0919854228405b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Instructions", + "Category": "Accessibility::Accessibility status message ", + "Description": "Instructions to be read after announcing the status.", + "IsDefault": false, + "PropertyKey": "a11yInstructions", + "ValueType": { + "$ID": "ff461bf2ce8243458762df0ab2cdd07d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "a6f28a5fafcc194dbdf216baaba9d2dc", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Use up and down arrow keys to navigate. Press Enter or Space Bar keys to select." + }, + { + "$ID": "a225af47adfd61458488cd96fa11980e", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Gebruik de pijltjestoetsen (omhoog en omlaag) om te navigeren. Druk op Enter of de spatiebalk om de waarde te selecteren." + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "855c1f90d0be0049ab3732a7efc8300d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Lazy loading", + "Category": "Advanced::Performance", + "Description": "", + "IsDefault": false, + "PropertyKey": "lazyLoading", + "ValueType": { + "$ID": "40116ac12039a647858827cd041e93e8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "82552d3d012af841a276a1796715fada", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Loading type", + "Category": "Advanced::Performance", + "Description": "", + "IsDefault": false, + "PropertyKey": "loadingType", + "ValueType": { + "$ID": "97b54b737b151e4ba1fd590a3e558018", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "spinner", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "054e0260aac8f942a308eec719f0392e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Spinner", + "_Key": "spinner" + }, + { + "$ID": "9192808a619ad34fa6b78f07bc6962cc", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Skeleton", + "_Key": "skeleton" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "e2996d42d90a15478592b7e310fd223c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selected items sorting", + "Category": "Advanced::Multiple-selection", + "Description": "How selected items should be sorted.", + "IsDefault": false, + "PropertyKey": "selectedItemsSorting", + "ValueType": { + "$ID": "61818e1393afd7479aea231e986a91e9", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "none", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "92314399f4aa9e4391ad746a761be1b9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Caption", + "_Key": "caption" + }, + { + "$ID": "4690d675704e4b40a8a240a528f44128", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Default", + "_Key": "none" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "05f9a77d8f1ca64b873edaa0a71b7719", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filter type", + "Category": "Advanced::Filter", + "Description": "", + "IsDefault": false, + "PropertyKey": "filterType", + "ValueType": { + "$ID": "6392dfadf2bc7f43a0aa8005f0c10677", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "contains", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "9e26eadda62fb34599f272c7a1ad3c1b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Contains (fuzzy)", + "_Key": "contains" + }, + { + "$ID": "369cd5239ec16d41a328fcf0ac612879", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Contains (exact)", + "_Key": "containsExact" + }, + { + "$ID": "1c8f73223d20bc45891eb51841fda809", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Starts-with", + "_Key": "startsWith" + }, + { + "$ID": "7d57b12b0026cd47825df2f63754f56e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "None", + "_Key": "none" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Display", + "StudioProCategory": "Input elements", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.combobox.Combobox", + "WidgetName": "Combo box", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "version": "11.6.3", + "widgetId": "com.mendix.widget.web.combobox.Combobox" +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/datagrid-date-filter.json b/modelsdk/widgets/templates/mendix-11.6/datagrid-date-filter.json new file mode 100644 index 00000000..aad8f3f3 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/datagrid-date-filter.json @@ -0,0 +1,1638 @@ +{ + "widgetId": "com.mendix.widget.web.datagriddatefilter.DatagridDateFilter", + "name": "Date filter", + "version": "11.6.3", + "extractedFrom": "bd1d6195-1b43-4e47-bd72-7331debae37e", + "type": { + "$ID": "fc455fbfe0793b4cb1080c629f012cca", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/modules/data-grid-2#7-1-date-filter", + "ObjectType": { + "$ID": "ba70183f8b771d47b6a40534255260c0", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "48661fb090a6a24dac72b65dce819ddd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filter attributes", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "attrChoice", + "ValueType": { + "$ID": "4f2c2acd2c431c44b2107b86dd0446d8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "auto", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "57aca921414f5e4eab3fb32521659eec", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto", + "_Key": "auto" + }, + { + "$ID": "bf51c371ea009540a2207c11de79bfdf", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Custom", + "_Key": "linked" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "1d701f92562c0641ac5788d396623f63", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Datasource to Filter", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "linkedDs", + "ValueType": { + "$ID": "044dce2a8271a84886717a56076c750d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": true, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "789814f5a3a3124aac5a0ed41ba20e06", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attributes", + "Category": "General::General", + "Description": "Select the attributes that the end-user may use for filtering.", + "IsDefault": false, + "PropertyKey": "attributes", + "ValueType": { + "$ID": "45dc8cc7dd65ad4ebba42b5f37836d49", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "baa3d0dbbdddf74697ce58660e129cc8", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "202792785047b24fade1e343e4fa4c2d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "attribute", + "ValueType": { + "$ID": "d467f1088adb944d8dfdff3006c9a3a1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "DateTime" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../linkedDs", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": true, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "55accbefae4c1e44bff1f9dcd8ced73d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Default value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "defaultValue", + "ValueType": { + "$ID": "f9cd65be2666c44ba6db38968cd20671", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "03ab90c460d79f4ba4ec679f98477750", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "DateTime" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "e7ccf788845eba49b6bf7f68fdae0e4e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Default start date", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "defaultStartDate", + "ValueType": { + "$ID": "edd4b26e4923b04598fb7ced2f50c9ae", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "ff7ae9b2621172478d1b6e4dcd2f67fe", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "DateTime" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "38576a3768331940b202865f95cd7401", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Default end date", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "defaultEndDate", + "ValueType": { + "$ID": "6a4073649bc06b45b3b97f007a170865", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "e94029b7bbbdcf448640e085c4fd2c6c", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "DateTime" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "59cd0b12c3b6a34d88cc0ab80116b5d5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Default filter", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "defaultFilter", + "ValueType": { + "$ID": "b883c7c8b9159449a312cc1b39cb1d8d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "equal", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "051b3f6598c31748b742a3cee3a91def", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Between", + "_Key": "between" + }, + { + "$ID": "9cc8f205b802f24dbea68f7d6864ae70", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Greater than", + "_Key": "greater" + }, + { + "$ID": "a65430c7984207478dd355c7cea62433", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Greater than or equal", + "_Key": "greaterEqual" + }, + { + "$ID": "430e9ad61ea9d547864da9e70e9f591c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Equal", + "_Key": "equal" + }, + { + "$ID": "f1b373f97b22a54fa2f64a13d5bf4579", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Not equal", + "_Key": "notEqual" + }, + { + "$ID": "4b3467876edfac45951d26e5c4883e97", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Smaller than", + "_Key": "smaller" + }, + { + "$ID": "f74655d89b9f454e88d2a54bbcd4cc6a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Smaller than or equal", + "_Key": "smallerEqual" + }, + { + "$ID": "b9e41431cdae9b498bda619ad1aa94cb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Empty", + "_Key": "empty" + }, + { + "$ID": "b341108e2e7aa140b19a1b08dbbf65be", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Not empty", + "_Key": "notEmpty" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "b75370f133ae9e4e9492bc28e811a08a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Placeholder", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "placeholder", + "ValueType": { + "$ID": "0db6b470f3661b4eb712d1d084aeefdc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "8cc83c6b60e0d94bb8f964a9f39f332b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Adjustable by user", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "adjustable", + "ValueType": { + "$ID": "1c65d2f29b187e449faf0c638ea26343", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "312f8f0ee09b6f44a4fdc1fb072e093f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Saved attribute", + "Category": "General::Configurations", + "Description": "Attribute used to store the last value of the filter.", + "IsDefault": false, + "PropertyKey": "valueAttribute", + "ValueType": { + "$ID": "8683117cbf90ad4bbe14acfab3b54053", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "DateTime" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "ede02498e52ea54480945c51b4fb1a59", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Saved start date attribute", + "Category": "General::Configurations", + "Description": "Attribute used to store the last value of the start date filter.", + "IsDefault": false, + "PropertyKey": "startDateAttribute", + "ValueType": { + "$ID": "b887892e96291d408a20a8827be9cdf4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "DateTime" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "c93c172c180c6e4995e2d4b431b87bb4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Saved end date attribute", + "Category": "General::Configurations", + "Description": "Attribute used to store the last value of the end date filter.", + "IsDefault": false, + "PropertyKey": "endDateAttribute", + "ValueType": { + "$ID": "ec32394f6237a94d8729142796058ffe", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "DateTime" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "ef793290b1882b44b6b583ba0467f912", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "General::Events", + "Description": "Action to be triggered when the value or filter changes.", + "IsDefault": false, + "PropertyKey": "onChange", + "ValueType": { + "$ID": "6081a991a992d64ca5836fba75af8e8e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "2ca11e50c9bbad4fb523507a2449a0cb", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Comparison button caption", + "Category": "Accessibility::Screen reader", + "Description": "Assistive technology will read this upon reaching the comparison button that triggers the filter type drop-down menu.", + "IsDefault": false, + "PropertyKey": "screenReaderButtonCaption", + "ValueType": { + "$ID": "51f8bec451e0f74ca50735ae94830b00", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "4cbe541ccbcd9c4e9fc0b167363b55ea", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Calendar button caption", + "Category": "Accessibility::Screen reader", + "Description": "Assistive technology will read this upon reaching the button that triggers the calendar.", + "IsDefault": false, + "PropertyKey": "screenReaderCalendarCaption", + "ValueType": { + "$ID": "0212ead200a60c42a43794ccd5f11c11", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "a821572dbd9a114491e9e67e514849f4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Input caption", + "Category": "Accessibility::Screen reader", + "Description": "Assistive technology will read this upon reaching the input element.", + "IsDefault": false, + "PropertyKey": "screenReaderInputCaption", + "ValueType": { + "$ID": "ddc65c3882b02846b5cd92c4ddc553ad", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Data Controls", + "StudioProCategory": "Data controls", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.datagriddatefilter.DatagridDateFilter", + "WidgetName": "Date filter", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "b3b0ef6e4ed029429770cba1206c675f", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "a90a41347c3a7e44bbf5428e953d5d22", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "55accbefae4c1e44bff1f9dcd8ced73d", + "Value": { + "$ID": "b8cdcefd7ce2a04aabb6a7ccab68a56e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e568c9ac71514e448bc1e8150375f8c0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f9cd65be2666c44ba6db38968cd20671", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "541ce2c21b021649bbaa1fbbda3f68f0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e7ccf788845eba49b6bf7f68fdae0e4e", + "Value": { + "$ID": "84f6d367eaf8b64aba56cd0872313665", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "761b59c594ee0b499239cbd39baff435", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "edd4b26e4923b04598fb7ced2f50c9ae", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0183d8b714b27d40b53ec4d9f573f74e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "38576a3768331940b202865f95cd7401", + "Value": { + "$ID": "e6d7a5f0ad7aea46a7828445d4a7ea15", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3c781bfe3d3c7349a1f731f4b25a6576", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6a4073649bc06b45b3b97f007a170865", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "59af2cde9148714183468ad75dd0c866", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "59cd0b12c3b6a34d88cc0ab80116b5d5", + "Value": { + "$ID": "d4d411a83d976044bc3896f4129f6981", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4a86b29405f1c948a6699cbef6c5e956", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "equal", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b883c7c8b9159449a312cc1b39cb1d8d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6c85b71006a87c4eae851ba452ae0fd1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b75370f133ae9e4e9492bc28e811a08a", + "Value": { + "$ID": "6444657b66ae7a48b498d36d2c8f0247", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "bd90bcf2790ca941935c8a31731d2b2d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "a350d5c4d9a43a42bb231f5bfc37daf7", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "2d631a4344e9e846a2f720da5a2290ae", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "87c2b8808529ad4ba656110823b08782", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "0db6b470f3661b4eb712d1d084aeefdc", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "7ff8fd4484f9954ab97002ad3268761a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8cc83c6b60e0d94bb8f964a9f39f332b", + "Value": { + "$ID": "77022b0229820a4e8db413ac23d5caac", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5595a759642ab34a9ea4d4aec0d207f3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1c65d2f29b187e449faf0c638ea26343", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5bcade88fc8ca948a8740b9a1cf73427", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "312f8f0ee09b6f44a4fdc1fb072e093f", + "Value": { + "$ID": "411e0a8535f4774f89c6b518bf33d0e9", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0dbc00332306ad46a6ad967512ea764a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8683117cbf90ad4bbe14acfab3b54053", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4d8f18586a92a6429764042561445ab6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ede02498e52ea54480945c51b4fb1a59", + "Value": { + "$ID": "5d2c873653604748991864a605234e48", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a29f153a800a3044ac51c926485c3512", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b887892e96291d408a20a8827be9cdf4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "64ab27869594e9409f6d5e6f368fd3a5", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c93c172c180c6e4995e2d4b431b87bb4", + "Value": { + "$ID": "e4976b7908188147a68f52e9640bc59d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9a2a552f747c1d4ba33d395bb2a28597", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ec32394f6237a94d8729142796058ffe", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2a87226c269d114888227674b5be0648", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ef793290b1882b44b6b583ba0467f912", + "Value": { + "$ID": "09b9c1de18080943997ca70558d2442f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "906199907d7c054a847025c411399d6e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6081a991a992d64ca5836fba75af8e8e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "281b809f97acb74ba1c9b60958c3c078", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2ca11e50c9bbad4fb523507a2449a0cb", + "Value": { + "$ID": "8c03964f0fc08f489d319da928882c18", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "31a9aad552e81246803ee00fbfe85db8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "ca6f0562f246ad42b5c053035ab6865f", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "ab460cec550ac84fa1b5879b56d50c5f", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "7942973f6f094b4ba42a5714cc671f33", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "51f8bec451e0f74ca50735ae94830b00", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8d15c3cd083e844bbc7cd5899af723f0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4cbe541ccbcd9c4e9fc0b167363b55ea", + "Value": { + "$ID": "dd5dbf7e21bd6547b29a4105d09d3c62", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8dc6dbe672504448a670ebc5e24f77eb", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "3b6cd7be667c7c4cb917d40c8a8b2911", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "fafa3589460a0148a49a515b825a1c0c", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "0f8cb8d83d02f845b85ef6afe4185cac", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "0212ead200a60c42a43794ccd5f11c11", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "648b483f4d998c4799f9f1a5523a698e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a821572dbd9a114491e9e67e514849f4", + "Value": { + "$ID": "7b88088618333d4eb451091fa41e8983", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9dfc59567d5b4048a33e890937972f08", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "7b4588c81cb49240a400d17ed4da82f6", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "e5950ff3f81bfa4e80efc0e9c9e761c2", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "8674cf9b55973947ae983125f10e5397", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "ddc65c3882b02846b5cd92c4ddc553ad", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ee34db803e0b7548be04b4740dd862df", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "48661fb090a6a24dac72b65dce819ddd", + "Value": { + "$ID": "05d2882a2fdf204b9c85c4111aeac139", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a21c2bf592e7d446b08d3ce169bd6d40", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "auto", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4f2c2acd2c431c44b2107b86dd0446d8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d32a78b2c9ed09439e2b862d21613a45", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1d701f92562c0641ac5788d396623f63", + "Value": { + "$ID": "157ab6df19a38b4f816b829b1438cfb0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e4e71a07f9017843929508a28d8f4e26", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "044dce2a8271a84886717a56076c750d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1a2a5beaa1d2c54dadd916f3677784c6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "789814f5a3a3124aac5a0ed41ba20e06", + "Value": { + "$ID": "c34fad479bd7cc4aa83a3d26e544c34f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a6397512a42d0b42ac34d55a39675553", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "45dc8cc7dd65ad4ebba42b5f37836d49", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "ba70183f8b771d47b6a40534255260c0" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/datagrid-dropdown-filter.json b/modelsdk/widgets/templates/mendix-11.6/datagrid-dropdown-filter.json new file mode 100644 index 00000000..9e2f4efb --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/datagrid-dropdown-filter.json @@ -0,0 +1,2487 @@ +{ + "widgetId": "com.mendix.widget.web.datagriddropdownfilter.DatagridDropdownFilter", + "name": "Dropdown filter", + "version": "11.6.3", + "extractedFrom": "bd1d6195-1b43-4e47-bd72-7331debae37e", + "type": { + "$ID": "425796719e0c8142bdaeb1e7be1eaacf", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/modules/data-grid-2#7-2-drop-down-filter", + "ObjectType": { + "$ID": "142d8ab655d45545bf1e145332f15ec4", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "3347e2ba23f0fc4fbd3f1c3f723a0cbf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filter by", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "baseType", + "ValueType": { + "$ID": "fba1a92450b95844bb7ea8c672cdc959", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "attr", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "6b4c34b35091b942b45036afda842ef2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Attribute", + "_Key": "attr" + }, + { + "$ID": "436f1f8b8fe47a4e9656d8566aabb270", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Association", + "_Key": "ref" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "e300775c6be3b64a919d920832eea1c4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Datasource to Filter", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "linkedDs", + "ValueType": { + "$ID": "908c026bed034f43a69912c511bad69c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": true, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "c93a8492e5d213498d3289825ef8ea1a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute config", + "Category": "General::Data source", + "Description": "\"Auto\" works only when the widget is placed in a Data grid column.", + "IsDefault": false, + "PropertyKey": "attrChoice", + "ValueType": { + "$ID": "eea44099e6cb754cbb546fca1c19467c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "auto", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "a4965d4e8bf31947bb304c0cbdd7952b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto", + "_Key": "auto" + }, + { + "$ID": "bd7dbabba64eeb4a988b62b88cfb9e96", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Custom", + "_Key": "linked" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "8cc042dfb7561247a8fcf1baf0a3bb5f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "attr", + "ValueType": { + "$ID": "9ff58c75b6729b4589ef7b2934df79d7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "Enum", + "Boolean" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "linkedDs", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": true, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "00cceff7e5f44e4d9af952003d427795", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Automatic options", + "Category": "General::Data source", + "Description": "Show options based on the references or the enumeration values and captions.", + "IsDefault": false, + "PropertyKey": "auto", + "ValueType": { + "$ID": "7990d182e3142d4ca30255d1644c6110", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "633c772fa2395544a631f42e43fac64e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Options", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "filterOptions", + "ValueType": { + "$ID": "51f283d606619f4cb3c11392ad99eb5c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "918f1044038a6d4aabf2aaeffbdaa7fa", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "119c72563d99b54f9174d9b6df03815d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "caption", + "ValueType": { + "$ID": "1e0f839d5f8c9449a033073b59652c39", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "ea6a170881cea04eb51a185597261c2e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "value", + "ValueType": { + "$ID": "093c65787d68e34a965e695a156ec762", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "c68e6dd08a45bc4780bf63c49379781f", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "41072c783f3dad45af0f25cf81a1fd22", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Entity", + "Category": "General::Data source", + "Description": "Set the entity to enable filtering over association.", + "IsDefault": false, + "PropertyKey": "refEntity", + "ValueType": { + "$ID": "4eb7fae460320246b8363862db1d1761", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1, + "Reference", + "ReferenceSet" + ], + "DataSourceProperty": "linkedDs", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": true, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "refOptions", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Association" + } + }, + { + "$ID": "f96abd9a2801f34fb38c471cf03bc184", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selectable objects", + "Category": "General::Data source", + "Description": "The options to show in the Drop-down filter widget.", + "IsDefault": false, + "PropertyKey": "refOptions", + "ValueType": { + "$ID": "8d558c4ddcee484d93c8eed3e113beca", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "8bd671d7ba69bb4d85df96746b37987e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption source", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "refCaptionSource", + "ValueType": { + "$ID": "f22e8e07e1e0c946b6f00d2f987309ac", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "attr", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "8a452e28b4499848ad950d46543fe887", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Attribute", + "_Key": "attr" + }, + { + "$ID": "964d3a8ec4549c4d90c3e090df676925", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Expression", + "_Key": "exp" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "2ce67f96d2ee8246830b1401ce6c9969", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "refCaption", + "ValueType": { + "$ID": "7f5dcbc68b94984cba7623fd14626def", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "refOptions", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "562ac698fdf4d744b73a770991d597c5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "refCaptionExp", + "ValueType": { + "$ID": "10e203205a64b6468e2fea38b5202a0f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "refOptions", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "b4318b43f356854eb0a3425f9691f7e8", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "a514ca268815a844bd099d5a985b58a2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Search attribute", + "Category": "General::Data source", + "Description": "Required when Filterable is set to yes", + "IsDefault": false, + "PropertyKey": "refSearchAttr", + "ValueType": { + "$ID": "ef5da17a807dad42b866e8aaa1c4f763", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "refOptions", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "261d2ab0c79f6c48bf2e60bbf7277d89", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Use lazy load", + "Category": "General::Data source", + "Description": "Lazy loading enables faster parent loading, but with personalization enabled, value restoration will be limited.", + "IsDefault": false, + "PropertyKey": "fetchOptionsLazy", + "ValueType": { + "$ID": "483f3bfb79154b4abad7d373da390f07", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "8a4841df7a046447bd600997e767ed37", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Default value", + "Category": "General::General", + "Description": "Empty option caption will be shown by default or if configured default value matches none of the options", + "IsDefault": false, + "PropertyKey": "defaultValue", + "ValueType": { + "$ID": "533c409a79861249807dec5b04a8d553", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "ff44ac5d99055f4582d4a17b6d7d873c", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "2790334784c96f4eb6ac69128521dee4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filterable", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "filterable", + "ValueType": { + "$ID": "e5aa02c619ec1345a7f5a9eb666dfa0b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "56bb6dd1ddaa5946a23d4457bf946a22", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Multiselect", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "multiSelect", + "ValueType": { + "$ID": "5862969914a82c47b28fa1bee3f3ff48", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "84845f079e86f042a8bf08bb2105e114", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Empty option caption", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "emptyOptionCaption", + "ValueType": { + "$ID": "1b7e43933878ff45a7c223385da564d7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "3ac8664d500f094eaadad885fb436f21", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "None" + }, + { + "$ID": "0f87a716f11f9d418cf03ea1aa110d7d", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Niets" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "895fd6e70c269243b68f4402975709dc", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Clearable", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "clearable", + "ValueType": { + "$ID": "64e718d80318af4a9b939d0420d427d6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "e1e7be7bcb83bf41a1c320f211f9c03b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show selected items as", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "selectedItemsStyle", + "ValueType": { + "$ID": "6d58d125c4bb954f896a663b8dc40516", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "text", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "cf3b5d0b2f73e04285c4770c10922365", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Text", + "_Key": "text" + }, + { + "$ID": "77f11e05ac57ce45a73dfbd713e4a981", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Labels", + "_Key": "boxes" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "fce42a5112cdc74aa61e82d86f122c38", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selection method", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "selectionMethod", + "ValueType": { + "$ID": "74f31514ba52c644a76b8c32e69f1c26", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "checkbox", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "aec15735c049394abf860094df2e8334", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Checkbox", + "_Key": "checkbox" + }, + { + "$ID": "2a1b86517dd3624fbd71436ab72c419e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Row click", + "_Key": "rowClick" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "a583f4c494402e4e8d2cab993181cfd6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Saved attribute", + "Category": "General::Configurations", + "Description": "Attribute used to store the last value of the filter. Associations are not supported.", + "IsDefault": false, + "PropertyKey": "valueAttribute", + "ValueType": { + "$ID": "45a667b207e10645b4271491c8193564", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "64cdc70e46efe04f8903a0de179c320c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "General::Events", + "Description": "Action to be triggered when the value or filter changes.", + "IsDefault": false, + "PropertyKey": "onChange", + "ValueType": { + "$ID": "ff5725c557b3bb418e749ec09a3cf20a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "c41fff32751a5a419895a4786497e7ef", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Input caption", + "Category": "Advanced::Accessibility", + "Description": "Assistive technology will read this upon reaching the input element.", + "IsDefault": false, + "PropertyKey": "ariaLabel", + "ValueType": { + "$ID": "ae4928baeb6bf843b94b24d0317ddce8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "ddb6bdbde83cc840849f92d16d0a32d3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Empty selection caption", + "Category": "Advanced::Texts", + "Description": "This text is shown if no options are selected. For example 'Select color' or 'No options are selected'.", + "IsDefault": false, + "PropertyKey": "emptySelectionCaption", + "ValueType": { + "$ID": "d7f5b65935cba546b9274c345be0b7b7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "3790ba501e9f6441a3bbf041fa6a5565", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Select" + }, + { + "$ID": "6e00cd9fa81c0049b18b4085f254babf", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Selecteer" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "3dd07ddf11ed554b9fffcdddaff4843e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filter input placeholder", + "Category": "Advanced::Texts", + "Description": "This text is shown as placeholder for filterable filters. For example 'Type to search'.", + "IsDefault": false, + "PropertyKey": "filterInputPlaceholderCaption", + "ValueType": { + "$ID": "c55b8edd87390745b6532d885a9f1d00", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "4d3ce7c51c238b42823aa2829fb7cfdf", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Search" + }, + { + "$ID": "e2acf5f74708214690715eaff465dc5b", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Zoeken" + } + ], + "Type": "TextTemplate" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Data Controls", + "StudioProCategory": "Data controls", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.datagriddropdownfilter.DatagridDropdownFilter", + "WidgetName": "Drop-down filter", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "3c8a468152ad6f43916ca83313e49b93", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "f0aab732c36c8b4a88ec142def4ba1aa", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "00cceff7e5f44e4d9af952003d427795", + "Value": { + "$ID": "e9f042a14f34594a9b91e0749e0312ac", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "db2a38710820f84daef002ee705adac8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7990d182e3142d4ca30255d1644c6110", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "18218a4d69e60746b9bd11bf3470b9a1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8a4841df7a046447bd600997e767ed37", + "Value": { + "$ID": "ee51fdf0ee8ffc4385bd7f6dde8a05c6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d52235aa6b2a1b4bb5c98f632706fedb", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "533c409a79861249807dec5b04a8d553", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e6f19bbeef9e9144a2191547439a836a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "633c772fa2395544a631f42e43fac64e", + "Value": { + "$ID": "1a90c1679e20914195c2939811e402b9", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "31f53157dcbed043900e20f4c0993d63", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "51f283d606619f4cb3c11392ad99eb5c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ba2a11f8e3620c4cbee873bbe39565e0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "84845f079e86f042a8bf08bb2105e114", + "Value": { + "$ID": "10e022f861a3b14fbbbf7a2b998993fa", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3db5b7500d3fe9478f143608cdef14d7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "af3931563d072947ab8dc4d8890917c7", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "0ecaf3a3c3d7974886174e0bc31793cf", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "5839c2234c144b4995fcd9df68928e35", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "1b7e43933878ff45a7c223385da564d7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c5417e5e1df1ef459d47e65b9ccbae93", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "56bb6dd1ddaa5946a23d4457bf946a22", + "Value": { + "$ID": "5fd797fb08411c4e87d6d7d559ab8d31", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8a2bf99b41db4a4fa860eb3917e7a334", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5862969914a82c47b28fa1bee3f3ff48", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9b56fc870829c0419b5d0bf6a26f8baa", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a583f4c494402e4e8d2cab993181cfd6", + "Value": { + "$ID": "c19015ec6c8fde46b54e76d515ee6b49", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7edbb296e7b64249a3646b90874a6136", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "45a667b207e10645b4271491c8193564", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a3d5c21e6f3d124cbe6436f8590a278f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "64cdc70e46efe04f8903a0de179c320c", + "Value": { + "$ID": "db70243abccce44084670bce0b44c4e5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "bd8c0d59d8d0fb488dda0fc3ec301d8e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ff5725c557b3bb418e749ec09a3cf20a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "fdd1e5ca40caad49800e9197e8acb580", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c41fff32751a5a419895a4786497e7ef", + "Value": { + "$ID": "ef765002f412ab4591bf1374eb9ead0a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "74f4aaa9c6873741ab1ee032d33de4a3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "34eb55aab194ed47bd1e04480eeace9a", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "5c59ed43fe447f458f12760e8c166f6f", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "6617d706da0dcf41b2f92eca517bf67a", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "ae4928baeb6bf843b94b24d0317ddce8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "28c84b15f1078340bc4d88848c1cda52", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2790334784c96f4eb6ac69128521dee4", + "Value": { + "$ID": "95722c7c12f1ce40b9ace90bae4aa7b0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "90c6853ab467d045b7ffd65ce46acd33", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e5aa02c619ec1345a7f5a9eb666dfa0b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8614c9854b6c5d4ab6062c6b161e97c2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "895fd6e70c269243b68f4402975709dc", + "Value": { + "$ID": "7703e8fa3aa69e4b83dbb0d4942d7fc9", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "10b4b576fa87b043aaf4b5231eba8623", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "64e718d80318af4a9b939d0420d427d6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d745b0c8c8bae443a86fdb6ba0a2aa48", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e1e7be7bcb83bf41a1c320f211f9c03b", + "Value": { + "$ID": "71a9df984552fa4f94e2ac59896e9406", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6f0a8a6d0dd6e94382012f5cc6559075", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "text", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6d58d125c4bb954f896a663b8dc40516", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f7ebe3b6eefa384cb5e26995cd904cee", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "fce42a5112cdc74aa61e82d86f122c38", + "Value": { + "$ID": "10b0e62ed06ea645b3de7142573028b7", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "da8c4c627ba7d543bdb530f849387af7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "checkbox", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "74f31514ba52c644a76b8c32e69f1c26", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bc667e45fbf9be4b822b4ac21a5a849a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3347e2ba23f0fc4fbd3f1c3f723a0cbf", + "Value": { + "$ID": "23492980af85394d95cedcdf7c004340", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3dcfe1cb12d3fc4b87e497237a7bf4bc", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "attr", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fba1a92450b95844bb7ea8c672cdc959", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1a93bce040b9f14485803f9f351ff8a4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e300775c6be3b64a919d920832eea1c4", + "Value": { + "$ID": "bf849b098937714988066cfa71f101c3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "71775414af74aa4ba055e9e2769953ce", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "908c026bed034f43a69912c511bad69c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "088e191a3f76854babda07840e1708b7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c93a8492e5d213498d3289825ef8ea1a", + "Value": { + "$ID": "7ea54d36c3bc3c43b432d15481637db7", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "72e25a53665ea2429d6dcf621a8e18fd", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "auto", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "eea44099e6cb754cbb546fca1c19467c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e2458bdb7310224186ff12522f472c42", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8cc042dfb7561247a8fcf1baf0a3bb5f", + "Value": { + "$ID": "96a0733f47b3da42a819eef97358deec", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a8db69ac3a04304890f543fc7a6600ce", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9ff58c75b6729b4589ef7b2934df79d7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1ced21ef0bc1484c84f68a9e35041e36", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "41072c783f3dad45af0f25cf81a1fd22", + "Value": { + "$ID": "90ca331394cb96479391e8a729ae50c9", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "30c44c424fda294b8c148ec0db5676d7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4eb7fae460320246b8363862db1d1761", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a56e56dc4699a34fa4fd2a118e9fafcc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f96abd9a2801f34fb38c471cf03bc184", + "Value": { + "$ID": "788ac26e7d918b4f85ec7331aad85735", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8f641fc12b468940b5b20a15097649b6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8d558c4ddcee484d93c8eed3e113beca", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "83dbaafbc6785544b15133ea110c7caa", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8bd671d7ba69bb4d85df96746b37987e", + "Value": { + "$ID": "710122727f161c4081dda026eefca791", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "134950405103354a9f88c863ce0af6b4", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "attr", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f22e8e07e1e0c946b6f00d2f987309ac", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8b23537aca397144bf46d9b583ee3013", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2ce67f96d2ee8246830b1401ce6c9969", + "Value": { + "$ID": "c06708846e6504409d7450198958f127", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e61f609e609fa447b3b8cc0de493a93a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7f5dcbc68b94984cba7623fd14626def", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "310f9c2900555c4fadede85269a7dbf1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "562ac698fdf4d744b73a770991d597c5", + "Value": { + "$ID": "0b52271bee5a7b46b3357c4f4254ec24", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5b5a75bffe2ea34cb390198f30e7c45c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "10e203205a64b6468e2fea38b5202a0f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "91ed1b50a5615641be49d4180dbc70ea", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a514ca268815a844bd099d5a985b58a2", + "Value": { + "$ID": "1fa1a2f43044184fa507799368fe1123", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "81f2d4cc2c45bc4b91f2318d6beda4ad", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ef5da17a807dad42b866e8aaa1c4f763", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0db0b26ec9040845b37c2e614ded535f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "261d2ab0c79f6c48bf2e60bbf7277d89", + "Value": { + "$ID": "25b53f421fba7149bd2027ba9dc29820", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "db006a237ca2454e8fad4d4dbc901dd7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "483f3bfb79154b4abad7d373da390f07", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "523d4c346d20314ca91f973852a068c2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ddb6bdbde83cc840849f92d16d0a32d3", + "Value": { + "$ID": "c6e646cac313264ebc26adc45ed4f9f1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ac70f83bd5fa904bbd95a01b6aadfc83", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "e52b8bdf5d54454ea9c7af31e6935c5b", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "e3d50e7911145a409a8f045b6e3f41c9", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "f60790c159a9564c86d52d8d4659e00f", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "f4307cf95f4018428abfd531de0f795a", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Select" + }, + { + "$ID": "e225bd12be7d904683b1da20b4d121f5", + "$Type": "Texts$Translation", + "LanguageCode": "nl_NL", + "Text": "Selecteer" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "d7f5b65935cba546b9274c345be0b7b7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d784759d9db94f429fd9da08361d60e9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3dd07ddf11ed554b9fffcdddaff4843e", + "Value": { + "$ID": "367698e258353944b502d3fd4d084e05", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d6dc52fc55ed5a4d84b4b21e64d15712", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c55b8edd87390745b6532d885a9f1d00", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "142d8ab655d45545bf1e145332f15ec4" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/datagrid-number-filter.json b/modelsdk/widgets/templates/mendix-11.6/datagrid-number-filter.json new file mode 100644 index 00000000..7bfdb8af --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/datagrid-number-filter.json @@ -0,0 +1,1258 @@ +{ + "extractedFrom": "f4f12968-5f14-4cc7-bbb9-d22a9e5cf5af", + "name": "Number filter", + "object": { + "$ID": "91198827cda445699f84a52bec160adb", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "992e52f799fb44b7b66a6fab502c5adc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f3eb537c0d949643b534642107dd3a9a", + "Value": { + "$ID": "7501636febfe4aeaac53a867cce46af1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5412d14b4ba140449ff678f431eb7ff9", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "auto", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "97457e3613452e4298439d1e03d49fe7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "db4ebf168a6b416ca446d347f02235de", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "36f79976652b2449a5575bdbb285bf9a", + "Value": { + "$ID": "db324f06f21a4e0e8beb842599057582", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e8e64e4218bd4ab4b6325f11a3c6f574", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "183a406ffc893648831279b8bce1d829", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2d2c22ceb2f54b34aaca3a6ead385126", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9893cceaac4e6d429516f44cc204b8c6", + "Value": { + "$ID": "4427a557f1864ecd93cd1f71b04c630a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3a828b2135614d76ac0bf0eccec87289", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "69ae46b4ace61e45a15dfaafb38aacfc", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0ba39bbd265340368627c12cbc28d099", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "08b77b2dabc7294f835309f8885a3044", + "Value": { + "$ID": "c84fad1d02424aa58fde31b76daff3ff", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d376d158bae3432f9ae0a405b05172b3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7d62de5e3bc2a54689616b37f82c5d14", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "71658730eec4415da61076f4df84c9a1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c2cd0e06036ec14d9816da4e07ef0e91", + "Value": { + "$ID": "4608f727214f489ba0dc4b885ec87cec", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b46058e16d3b49699379b1ddee40dfdc", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "equal", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c6c8486f5377134e962c78170762ff3f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5d51abf9104d4123a2a5175b43c521fe", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "27569628ee8fe447bb0161ff47e6ea25", + "Value": { + "$ID": "53d84f9b8e2b416c95540b9b6cfa1fcf", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "97e828deecb5492f9b49dd74fac5e951", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "dd2b3c4d5e6f700100000000000001a0", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "dd2b3c4d5e6f700100000000000001a1", + "$Type": "Texts$Text", + "Items": [] + }, + "Parameters": [], + "Template": { + "$ID": "dd2b3c4d5e6f700100000000000001a2", + "$Type": "Texts$Text", + "Items": [] + } + }, + "TranslatableValue": null, + "TypePointer": "2d2f94c12aaefa40af87a5409cf7c49b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e3f631df20ca4b2d8c7e654b1999e655", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ee8126cc7e5ba1438517e8fb883c02b2", + "Value": { + "$ID": "e560d27369cc477f836333b620b07bcb", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "84179e83f7a64010923c202506f4d65f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ba287caf97823a47909f3ab88de7c74f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5f21b3e0c7084a5788804688b1e2fb1a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b98e5568f038b34ca6ab79d2a0521f2f", + "Value": { + "$ID": "d00f829dee2d40ac887d2f9cf32ede38", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b865ce1c618e4d4aa05fb369def7eecb", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "500", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "788fc7ddf65291408cf60cc2be31eaf5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ec6f926c9dca44808b3646d0029110d9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cd2fa2eed5f1df4ea2ae157780ea63da", + "Value": { + "$ID": "37897a928e24485abe0547f9dfef294a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e9f4a1225e6d470eb39917eb1bf282c6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "be82eba905602842a5d7251be45809d3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "fdb8d8af5251402d95aad4944ef57da6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cfe00f9dbbb7984681906e56a93e6a22", + "Value": { + "$ID": "09d2293ae0b54d50968ca30115c4b582", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "89debf0b315142198024ca043f2b2fa1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b75e2886fd93d94daaf76cd3ebf4472b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a8a47a935a4a461581ccdd281c3ae3c7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7294d1df8f31d34fa81bc7b7a23c9089", + "Value": { + "$ID": "0d875ea46ca54f5ebcf004498e09fa4c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f6c034a956fa4495b6853829aa2c8a96", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "dd2b3c4d5e6f700200000000000002a0", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "dd2b3c4d5e6f700200000000000002a1", + "$Type": "Texts$Text", + "Items": [] + }, + "Parameters": [], + "Template": { + "$ID": "dd2b3c4d5e6f700200000000000002a2", + "$Type": "Texts$Text", + "Items": [] + } + }, + "TranslatableValue": null, + "TypePointer": "edba3d309529b147b6ec45858656e4b2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f018357176ba4f438948f5fd1d991a7c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e735984c1724f94abeaeb09951f4ed82", + "Value": { + "$ID": "493c5587aaae4cf7a0016b5929154743", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d5f91dcb7492469793b4b6e756f176f1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "dd2b3c4d5e6f700300000000000003a0", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "dd2b3c4d5e6f700300000000000003a1", + "$Type": "Texts$Text", + "Items": [] + }, + "Parameters": [], + "Template": { + "$ID": "dd2b3c4d5e6f700300000000000003a2", + "$Type": "Texts$Text", + "Items": [] + } + }, + "TranslatableValue": null, + "TypePointer": "0fff121b4224274da45331812b687024", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "473c2169eaaf4541aca09a69f761ce38" + }, + "type": { + "$ID": "722669a6385094429e233c3f558a4569", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/modules/data-grid-2#7-3-number-filter", + "ObjectType": { + "$ID": "473c2169eaaf4541aca09a69f761ce38", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "f3eb537c0d949643b534642107dd3a9a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filter attributes", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "attrChoice", + "ValueType": { + "$ID": "97457e3613452e4298439d1e03d49fe7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "auto", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "57d0d607e8d339439b3ce379cc4c7db4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto", + "_Key": "auto" + }, + { + "$ID": "2760bdde241f4741af4388f573976601", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Custom", + "_Key": "linked" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "36f79976652b2449a5575bdbb285bf9a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Datasource to Filter", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "linkedDs", + "ValueType": { + "$ID": "183a406ffc893648831279b8bce1d829", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": true, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "9893cceaac4e6d429516f44cc204b8c6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attributes", + "Category": "General::General", + "Description": "Select the attributes that the end-user may use for filtering.", + "IsDefault": false, + "PropertyKey": "attributes", + "ValueType": { + "$ID": "69ae46b4ace61e45a15dfaafb38aacfc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "b8f21a9d23e4bc48b5d9821d62dcc93c", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "f91eb5abe3a9944aa1fdba48ed1c0181", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "attribute", + "ValueType": { + "$ID": "9e93ddca5653af41b3eb9283346e6500", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "AutoNumber", + "Decimal", + "Integer", + "Long" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../linkedDs", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": true, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "08b77b2dabc7294f835309f8885a3044", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Default value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "defaultValue", + "ValueType": { + "$ID": "7d62de5e3bc2a54689616b37f82c5d14", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "7ff5515200bf814b8654e77c489e4cfc", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "c2cd0e06036ec14d9816da4e07ef0e91", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Default filter", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "defaultFilter", + "ValueType": { + "$ID": "c6c8486f5377134e962c78170762ff3f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "equal", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "ca5052f5421876438881d45c2f1d93c6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Greater than", + "_Key": "greater" + }, + { + "$ID": "5105fc9552591047b29e30ff155f49ed", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Greater than or equal", + "_Key": "greaterEqual" + }, + { + "$ID": "e4d49acb000a9944bd102e0b9f79f8f7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Equal", + "_Key": "equal" + }, + { + "$ID": "d36459617ea5cd45b4ddd980c29254bf", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Not equal", + "_Key": "notEqual" + }, + { + "$ID": "5338cefc04eacf42b9a3dba233733c94", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Smaller than", + "_Key": "smaller" + }, + { + "$ID": "914268def57596439c9c62fdb343abf5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Smaller than or equal", + "_Key": "smallerEqual" + }, + { + "$ID": "80a224062d1b4549b6f9c7a9da0500aa", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Empty", + "_Key": "empty" + }, + { + "$ID": "a0f30ac276f0e248a8a176ebf1f867fc", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Not empty", + "_Key": "notEmpty" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "27569628ee8fe447bb0161ff47e6ea25", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Placeholder", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "placeholder", + "ValueType": { + "$ID": "2d2f94c12aaefa40af87a5409cf7c49b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "ee8126cc7e5ba1438517e8fb883c02b2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Adjustable by user", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "adjustable", + "ValueType": { + "$ID": "ba287caf97823a47909f3ab88de7c74f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "b98e5568f038b34ca6ab79d2a0521f2f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Apply after (ms)", + "Category": "General::On change behavior", + "Description": "Wait this period before applying then change(s) to the filter", + "IsDefault": false, + "PropertyKey": "delay", + "ValueType": { + "$ID": "788fc7ddf65291408cf60cc2be31eaf5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "500", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "cd2fa2eed5f1df4ea2ae157780ea63da", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Saved attribute", + "Category": "General::Configurations", + "Description": "Attribute used to store the last value of the filter.", + "IsDefault": false, + "PropertyKey": "valueAttribute", + "ValueType": { + "$ID": "be82eba905602842a5d7251be45809d3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "AutoNumber", + "Decimal", + "Integer", + "Long" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "cfe00f9dbbb7984681906e56a93e6a22", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "General::Events", + "Description": "Action to be triggered when the value or filter changes.", + "IsDefault": false, + "PropertyKey": "onChange", + "ValueType": { + "$ID": "b75e2886fd93d94daaf76cd3ebf4472b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "7294d1df8f31d34fa81bc7b7a23c9089", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Comparison button caption", + "Category": "Accessibility::Screen reader", + "Description": "Assistive technology will read this upon reaching the comparison button that triggers the filter type drop-down menu.", + "IsDefault": false, + "PropertyKey": "screenReaderButtonCaption", + "ValueType": { + "$ID": "edba3d309529b147b6ec45858656e4b2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "e735984c1724f94abeaeb09951f4ed82", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Input caption", + "Category": "Accessibility::Screen reader", + "Description": "Assistive technology will read this upon reaching the input element.", + "IsDefault": false, + "PropertyKey": "screenReaderInputCaption", + "ValueType": { + "$ID": "0fff121b4224274da45331812b687024", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "c19c9737783b12439b1e3861dbee11b7", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Search" + }, + { + "$ID": "1e91af09ded37c4da7c3800185f63bd7", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "de_DE", + "Text": "Suche" + }, + { + "$ID": "f3c7a143d56457469adb314ffda31645", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Zoeken" + } + ], + "Type": "TextTemplate" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Data Controls", + "StudioProCategory": "Data controls", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.datagridnumberfilter.DatagridNumberFilter", + "WidgetName": "Number filter", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "version": "11.6.0", + "widgetId": "com.mendix.widget.web.datagridnumberfilter.DatagridNumberFilter" +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/datagrid-text-filter.json b/modelsdk/widgets/templates/mendix-11.6/datagrid-text-filter.json new file mode 100644 index 00000000..69a65186 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/datagrid-text-filter.json @@ -0,0 +1,1289 @@ +{ + "widgetId": "com.mendix.widget.web.datagridtextfilter.DatagridTextFilter", + "name": "Text filter", + "version": "11.6.3", + "extractedFrom": "abe986a0-69d9-4957-9e9c-7de54bc709d4", + "type": { + "$ID": "518f1ca732e3be45b39f626ecd5670b7", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/modules/data-grid-2#7-4-text-filter", + "ObjectType": { + "$ID": "18ba271767b58e4a8d03e6f5907cb936", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "390b965dfed86e44ba20b44738128495", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filter attributes", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "attrChoice", + "ValueType": { + "$ID": "fe95acff2eb35547abc52034b2435328", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "auto", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "8a64eb2fedddfe489f819f94dd655a68", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto", + "_Key": "auto" + }, + { + "$ID": "c6dc7c85af654344a8519b34d512bc9d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Custom", + "_Key": "linked" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "db4fa427d3e44340b397fc384a148be4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Datasource to Filter", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "linkedDs", + "ValueType": { + "$ID": "058cb028948dc44284013eeabcf4d0bf", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": true, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "40408772e446d940b5596892fce346eb", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attributes", + "Category": "General::General", + "Description": "Select the attributes that the end-user may use for filtering.", + "IsDefault": false, + "PropertyKey": "attributes", + "ValueType": { + "$ID": "a669d2045c75004391dc93c6da9b56c6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "48668cf97627ab4f887bc5d7ee0c5572", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "e7bd3305945e4b4e82a1b81c1625bea5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "attribute", + "ValueType": { + "$ID": "399870afc76bfd499e5ac034142be79f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../linkedDs", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": true, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "2f88bd75904b7d4ea608db0d4c84681f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Default value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "defaultValue", + "ValueType": { + "$ID": "4d1635d3ab151d4eb2bbbfac6b7a1355", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "38bde1288f1ca24e948ff0a47f6d9bb9", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "54c153d14a5a1a45a0fc023eb1ae60bf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Default filter", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "defaultFilter", + "ValueType": { + "$ID": "cb55fc20da486148b900072180915064", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "contains", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "febcb58acdb2f3449d309b7ac380277f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Contains", + "_Key": "contains" + }, + { + "$ID": "e8332032ec465d4396f3494fbf2b46bb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Starts with", + "_Key": "startsWith" + }, + { + "$ID": "049ae48613dd8f4086976344c17f0e24", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Ends with", + "_Key": "endsWith" + }, + { + "$ID": "9f9aa994959549489ae21ce765814b96", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Greater than", + "_Key": "greater" + }, + { + "$ID": "d271d6949e74034bb397122af5fc3d94", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Greater than or equal", + "_Key": "greaterEqual" + }, + { + "$ID": "7215439dae543c4f8e8a3400f172fc3f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Equal", + "_Key": "equal" + }, + { + "$ID": "d58c7cdb7c251a4fa74227b87b5a0cd3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Not equal", + "_Key": "notEqual" + }, + { + "$ID": "c63003bfc9ba7a4c9d3dffbcedeb61d9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Smaller than", + "_Key": "smaller" + }, + { + "$ID": "56735339c5a24345a868b3ef51ace6f2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Smaller than or equal", + "_Key": "smallerEqual" + }, + { + "$ID": "596627d7b5e37e40a64f945ae20ef187", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Empty", + "_Key": "empty" + }, + { + "$ID": "06b15887ac4f314383993bb9a13b69c1", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Not empty", + "_Key": "notEmpty" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "4d35c037c0a5c742930c019495d21c21", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Placeholder", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "placeholder", + "ValueType": { + "$ID": "2fe46b0586ff674eaa0925b8913b1be2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "d47bf8f143f4af47bd68e3f95626e60f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Adjustable by user", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "adjustable", + "ValueType": { + "$ID": "b365cc87a4595f46b995f07a6df4632e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "1a46c979b5700b44856db249bfa28a3a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Apply after (ms)", + "Category": "General::On change behavior", + "Description": "Wait this period before applying then change(s) to the filter", + "IsDefault": false, + "PropertyKey": "delay", + "ValueType": { + "$ID": "0b6b2a084079d24697ef2c472fc85455", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "500", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "be8851245c90f0448b85801544b784c6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Saved attribute", + "Category": "General::Configurations", + "Description": "Attribute used to store the last value of the filter.", + "IsDefault": false, + "PropertyKey": "valueAttribute", + "ValueType": { + "$ID": "38c7838da819204f9c6e3c62c245b2e4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String", + "HashString" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "232a4b4391630a4786bcd395bcf91ac7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "General::Events", + "Description": "Action to be triggered when the value or filter changes.", + "IsDefault": false, + "PropertyKey": "onChange", + "ValueType": { + "$ID": "3b5d3fe99b18ea4ba338db6a80c722e5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "c3c335173060e447af18f940ef9ce668", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Comparison button caption", + "Category": "Accessibility::Screen reader", + "Description": "Assistive technology will read this upon reaching the comparison button that triggers the filter type drop-down menu.", + "IsDefault": false, + "PropertyKey": "screenReaderButtonCaption", + "ValueType": { + "$ID": "1b90026157a7db468528d73a1b84e89e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "81a6c65be5bbb94f94809db99aa0cfad", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Input caption", + "Category": "Accessibility::Screen reader", + "Description": "Assistive technology will read this upon reaching the input element.", + "IsDefault": false, + "PropertyKey": "screenReaderInputCaption", + "ValueType": { + "$ID": "66faf4168a751c41a81ee055fa8276f1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "ef89e604803d034d8cf7c73558583474", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Search" + }, + { + "$ID": "a8bc65c4016d7043871399d68716ebec", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "de_DE", + "Text": "Suche" + }, + { + "$ID": "4bed0edc797ab9479857d98d1f4a4d87", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "nl_NL", + "Text": "Zoeken" + } + ], + "Type": "TextTemplate" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Data Controls", + "StudioProCategory": "Data controls", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.datagridtextfilter.DatagridTextFilter", + "WidgetName": "Text filter", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "22a8d7f9e412f1478a5a45de18f1d3bd", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "cf90acfc3670614a8f10553a20cd7dcd", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2f88bd75904b7d4ea608db0d4c84681f", + "Value": { + "$ID": "c5222146587d1c40b2775960c4a24269", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "63ee9a0812e1fe4393266943047d3e70", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4d1635d3ab151d4eb2bbbfac6b7a1355", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5b43dd44c09bbc4c92757bfa5304294b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "54c153d14a5a1a45a0fc023eb1ae60bf", + "Value": { + "$ID": "23972a908481c840b99f73b2400fc8ec", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9cbd142c28d78e4db75392ed89495229", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "contains", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cb55fc20da486148b900072180915064", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f538bfc82d2e1647997f39716c223707", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4d35c037c0a5c742930c019495d21c21", + "Value": { + "$ID": "4f65e94a9b2c5c4bb3a284383bd058c2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7c5d45c035588441882d4d80536b69d6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "d5f3c95288034f42aba2c7294d3688cb", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "d7eace011f33234f9e0aa38a19e41a7f", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "190838dd42007140a05054441a446a13", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "2fe46b0586ff674eaa0925b8913b1be2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6c8408f8986bcb48897229bc9b33e436", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d47bf8f143f4af47bd68e3f95626e60f", + "Value": { + "$ID": "cbac577a2d323c48a821222ef38b9d5e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "fedde9d3bd7a3b45b7b4b9f319d1d401", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b365cc87a4595f46b995f07a6df4632e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5cf15f05aae34e4da7ef131ea9e4a639", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1a46c979b5700b44856db249bfa28a3a", + "Value": { + "$ID": "05965f757b81724aadac70eef3ecea33", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8e97d8f198893744ab9f70bb5ac34032", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "500", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0b6b2a084079d24697ef2c472fc85455", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d51e5f329bd3bb43ab2be8d5b2022943", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "be8851245c90f0448b85801544b784c6", + "Value": { + "$ID": "c77b9dde1f7f5343a29bb22320b7a052", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d369a389d6c49b49b2f4af3b24c12a0d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "38c7838da819204f9c6e3c62c245b2e4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a7671ab57607c24589c699dbc93ad640", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "232a4b4391630a4786bcd395bcf91ac7", + "Value": { + "$ID": "865d9cbc6cc6234daa7e8505e011f87c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1aac9733239d2d4480ef1c01a619d7e0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "3b5d3fe99b18ea4ba338db6a80c722e5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a30c2a7d05cfd64ab3cbb414355ca498", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c3c335173060e447af18f940ef9ce668", + "Value": { + "$ID": "dc743fa9f1221b458bbce2caa9881c68", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "252a7ccd7671b942be28744ed89b8f09", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "7fb6ecdf331ef64fa3a52bf320867397", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "7e202c4b80ffcb4289ac4fc46b02a545", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "ee500490e6e6c54d95a2b45cebc76c6f", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "1b90026157a7db468528d73a1b84e89e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cedefdb01c71c84b8573bf86e4583bcc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "81a6c65be5bbb94f94809db99aa0cfad", + "Value": { + "$ID": "93739163227a0140a2d4e034ad5a1892", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "51e68ae37135ab4dbe151e4523c667d5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "b2564ed613133e44a63f605821ec548c", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "e9a2348321fd784b88888663acd3dde6", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "25e5dd1c08c8cd40b843741894ad3950", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "66faf4168a751c41a81ee055fa8276f1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4c1b7d017fa0914d9bbb5541329b2541", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "390b965dfed86e44ba20b44738128495", + "Value": { + "$ID": "a9d087093400784caaa43ddaff796671", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "19b3e3bff68f5d4680161a2e0909e125", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "auto", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fe95acff2eb35547abc52034b2435328", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cee2b1e82fc600468586af6b546659c9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "db4fa427d3e44340b397fc384a148be4", + "Value": { + "$ID": "c2a00e3b4a9e134ab623979ae9161260", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5bd906e9d83deb44850b7b66709b2923", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "058cb028948dc44284013eeabcf4d0bf", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2bfe4d3a2fb2544e9cac40d9821f253b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "40408772e446d940b5596892fce346eb", + "Value": { + "$ID": "00241ed45e19774ab7fe1228ee536f5c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "24b61598e7883b4d8a2b45d8eeb1a8c3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a669d2045c75004391dc93c6da9b56c6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "18ba271767b58e4a8d03e6f5907cb936" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/datagrid.json b/modelsdk/widgets/templates/mendix-11.6/datagrid.json new file mode 100644 index 00000000..b2d366f8 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/datagrid.json @@ -0,0 +1,7491 @@ +{ + "widgetId": "com.mendix.widget.web.datagrid.Datagrid", + "name": "Data grid 2", + "version": "11.6.3", + "extractedFrom": "23a822d9-94fd-44ed-98bc-7f7b9f7bd425", + "type": { + "$ID": "d6dc4600d7fc694d8b51119721aea715", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/modules/data-grid-2", + "ObjectType": { + "$ID": "dd790ecbaa33e948981485dacb8e9d85", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "8e6dc61f82a9a544ac8d89566dd84e39", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Enable advanced options", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "advanced", + "ValueType": { + "$ID": "6f94cb2ac769164fbf2bd0a9fa6bac4b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "2b22ef610db1a34d8d07bc9483939b35", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Data source", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "datasource", + "ValueType": { + "$ID": "244f87de3808fd4fac538e15febc9700", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "c336275df77b984b95b4d13b9d008bb5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Refresh time (in seconds)", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "refreshInterval", + "ValueType": { + "$ID": "054188bdead2344da9de05b61a483cdc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "0", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "eaba539f116f7342b3d8c54a49787446", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selection", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "itemSelection", + "ValueType": { + "$ID": "2e6b8a8d2647e641b0bfaf28a121a51c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1, + "None", + "Single", + "Multi" + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Selection" + } + }, + { + "$ID": "5a51339ec4f5784b99317d8621c92960", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selection method", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "itemSelectionMethod", + "ValueType": { + "$ID": "36f02171758cf2498d840778b310f5a3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "checkbox", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "a96534fac4377c4da1d63404d4940f56", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Checkbox", + "_Key": "checkbox" + }, + { + "$ID": "217f9f07d94d024d83af9507559b77be", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Row click", + "_Key": "rowClick" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "d9495be7dd3e5f44976bb6d0c39a32b9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Toggle on click", + "Category": "General::General", + "Description": "Defines item selection behavior.", + "IsDefault": false, + "PropertyKey": "itemSelectionMode", + "ValueType": { + "$ID": "da0e08557d42ce4497662067c8fe0e2c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "clear", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "ff9363b2c7a67147a18cf3fcdb4bba64", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Yes", + "_Key": "toggle" + }, + { + "$ID": "9760f9cc80bb284d9e4c1ec0bb891579", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "No", + "_Key": "clear" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "e1bcad535ec16c418bff03e1c38954fd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show (un)check all toggle", + "Category": "General::General", + "Description": "Show a checkbox in the grid header to check or uncheck multiple items.", + "IsDefault": false, + "PropertyKey": "showSelectAllToggle", + "ValueType": { + "$ID": "2939fa612d463348bfdc52be8ab31835", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "80d67ae2e93ed0429ea102f1d80cc249", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Keep selection", + "Category": "General::General", + "Description": "If enabled, selected items will stay selected unless cleared by the user or a Nanoflow.", + "IsDefault": false, + "PropertyKey": "keepSelection", + "ValueType": { + "$ID": "1d242b405c836e4683ddb27e5e7df6ba", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "7b3fc1dd6948d34a99578293b2cf21e9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Loading type", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "loadingType", + "ValueType": { + "$ID": "9fd1ad2a9da5664a944321231bf97571", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "spinner", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "50fac8badf71514ab5e628b1c912e526", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Spinner", + "_Key": "spinner" + }, + { + "$ID": "5abed1907332e2409922b3f6f08bcd84", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Skeleton", + "_Key": "skeleton" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "4386087aa57f3a4491639ab7be4ed3cf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show refresh indicator", + "Category": "General::General", + "Description": "Show a refresh indicator when the data is being loaded.", + "IsDefault": false, + "PropertyKey": "refreshIndicator", + "ValueType": { + "$ID": "34643e1f3bff584cb6f830b7d760a3d2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "b25ffbc435d0a745ad48c22603f5bc4b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Columns", + "Category": "General::Columns", + "Description": "", + "IsDefault": false, + "PropertyKey": "columns", + "ValueType": { + "$ID": "80f04496ab45374ea73a77fec76ee303", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "08a2e91acbe0fa469f51aad8e32e8c91", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "42b23beb7e4ec0419b0d4b9bb6808ea7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "showContentAs", + "ValueType": { + "$ID": "d08468fadf9e8947b713dfc3031a55e5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "attribute", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "22ae0b248b47ef4e96ac29beafa53c16", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Attribute", + "_Key": "attribute" + }, + { + "$ID": "cce977a55a9c1c42ad25e3d5364695eb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Dynamic text", + "_Key": "dynamicText" + }, + { + "$ID": "1e353e586d2d2842b8444d499a31e8ea", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Custom content", + "_Key": "customContent" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "19bc7fbbe39eb34eb060a709cfab3ed7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "General", + "Description": "Attribute is required if the column can be sorted or filtered", + "IsDefault": false, + "PropertyKey": "attribute", + "ValueType": { + "$ID": "891d56daea68d34cbe0c861593256290", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String", + "AutoNumber", + "Boolean", + "DateTime", + "Decimal", + "Enum", + "Integer", + "Long" + ], + "AssociationTypes": [ + 1, + "Reference", + "ReferenceSet" + ], + "DataSourceProperty": "../datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "709628f1195f9042a053377eed3be9b7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom content", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "content", + "ValueType": { + "$ID": "aa67c6469eb18f4b98839c9ab3f9ba40", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "3f0f2f5ea82d714f871e2924cbf48a04", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Dynamic text", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicText", + "ValueType": { + "$ID": "31eeffd78901ee46a8d2dbb1096883ac", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "439036c51e60ff4ab7c48ad338fb2b98", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Export value", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "exportValue", + "ValueType": { + "$ID": "2a85a05a84266a40a8bd785f31bef5c7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "e814f7f0741e744faf7c2d19644b5ab7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "header", + "ValueType": { + "$ID": "3229189af9732148b9ccf0b2b8c4b54e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "2c6165ee98ed204baa53bccbf70bb228", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "tooltip", + "ValueType": { + "$ID": "8307088dfe9ae747821cfa38b39340db", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "64b4d33dd9fce547a00c94b1dcf4d6cb", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filter", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "filter", + "ValueType": { + "$ID": "9289d2ade6b0a245b1ccc86590fcfffa", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "4a6f429cbc60944f9211f9298e0a0c28", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Visible", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "visible", + "ValueType": { + "$ID": "5b422d79d625a24bb7acb057f0cc044e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "22492bd5b5d1fe449a067162c6c17360", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Boolean" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "6d2823abd5ff064096a10cfaa36cb62a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Can sort", + "Category": "Column capabilities", + "Description": "", + "IsDefault": false, + "PropertyKey": "sortable", + "ValueType": { + "$ID": "1a3635856b495f4db370409a36d14de6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "cc9a2bbc1c0ca84ba6b5d8d3d5e5fd6c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Can resize", + "Category": "Column capabilities", + "Description": "", + "IsDefault": false, + "PropertyKey": "resizable", + "ValueType": { + "$ID": "b582b02df0b14b4e80c70e641ec1374d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "cb8fb2c675f14f4299bce269c1cd2942", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Can reorder", + "Category": "Column capabilities", + "Description": "", + "IsDefault": false, + "PropertyKey": "draggable", + "ValueType": { + "$ID": "9a8c88dc898a7c47a42e9799a3601b43", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "3bcd7d3aa449724aadfda0d46082e717", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Can hide", + "Category": "Column capabilities", + "Description": "", + "IsDefault": false, + "PropertyKey": "hidable", + "ValueType": { + "$ID": "e82e6cee19fc27458ebba7a8ae21496e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "yes", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "1d4e8e6884fc1243b2c4fa6a737772f5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Yes", + "_Key": "yes" + }, + { + "$ID": "da1b67e8efe1274199b7c082176eae34", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Yes, hidden by default", + "_Key": "hidden" + }, + { + "$ID": "01d81f3756e5774abca0ea6f3aa79163", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "No", + "_Key": "no" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "3669ed18ca24b74aac9aaa695210a5c5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Allow row events", + "Category": "Column capabilities", + "Description": "If set to yes, then all default events on the row, such as \"on click\" or selection, will be triggered when the user interacts with custom content.", + "IsDefault": false, + "PropertyKey": "allowEventPropagation", + "ValueType": { + "$ID": "f5f0faaed054c84bb92adc30f3746487", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "368826bcdb056d4480e5955cdd4f44b1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Column width", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "width", + "ValueType": { + "$ID": "62c0fc9c4e01e3438854084fb52167f9", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "autoFill", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "67a09c11461838498f7461e7f993504a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto-fill", + "_Key": "autoFill" + }, + { + "$ID": "034f10e826b0e04cae24e5de5efeb7d8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto-fit content", + "_Key": "autoFit" + }, + { + "$ID": "e6cb0a519ca6b243bed944ba80abe23e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Manual", + "_Key": "manual" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "92bb2d8ad8c41849b43246a7270cbc95", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Min width", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "minWidth", + "ValueType": { + "$ID": "2e3d7bd7ef8f8a46a03804eba5bd6765", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "auto", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "460e46e62f556544aaaa3b2242c72c86", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto", + "_Key": "auto" + }, + { + "$ID": "b47bd80cc57ba3419fa817c3ab01df85", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Set by content", + "_Key": "minContent" + }, + { + "$ID": "2ccee443b1931342a880050bf3c637fe", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Manual", + "_Key": "manual" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "3fc28169fdd8e848aa70ed35425f0f2d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Min width value (px)", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "minWidthLimit", + "ValueType": { + "$ID": "1b36b872c581a14589a9223b58e11bfa", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "c60605f54797444dafbe51917a7711e9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Column size", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "size", + "ValueType": { + "$ID": "25369751340a784ab6507e09637f05a6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "1", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "3be7976bdbc1834aa7cfada2585a71e7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Alignment", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "alignment", + "ValueType": { + "$ID": "65db3a93520f82408a833caeadbbd110", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "left", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "c6c346970c56b445b8612c6c33c2da4c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Left", + "_Key": "left" + }, + { + "$ID": "6812235b8c6a254e9571643d759ddc55", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Center", + "_Key": "center" + }, + { + "$ID": "86ec07d35054b84e81ab7c0f272b604d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Right", + "_Key": "right" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "78949d0fef5c2142b2071c125e2792cf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Dynamic cell class", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "columnClass", + "ValueType": { + "$ID": "752ba62b5ad0b4429f0ac27cb36a491d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "489f0b79ae985042aa7da7496f64c0f3", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "1138296ab096e64fb2a990d9850c5d29", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Wrap text", + "Category": "Appearance", + "Description": "", + "IsDefault": false, + "PropertyKey": "wrapText", + "ValueType": { + "$ID": "b97b4b7cd4d2b04cb9239e07c4b9fda4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "c8a4595e65efd94d9496d3914acd7c5a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show column filters", + "Category": "General::Columns", + "Description": "", + "IsDefault": false, + "PropertyKey": "columnsFilterable", + "ValueType": { + "$ID": "eab5c3373837c34ba225bfee65a59b55", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "86b4a7024b764c4295a2f58565254cbc", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Page size", + "Category": "General::Rows", + "Description": "", + "IsDefault": false, + "PropertyKey": "pageSize", + "ValueType": { + "$ID": "bf6726c0e92ef54d8032a5447526f8d4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "20", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "54ab01ea8616e44fac53cfc21fa43ffd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Pagination", + "Category": "General::Rows", + "Description": "", + "IsDefault": false, + "PropertyKey": "pagination", + "ValueType": { + "$ID": "4e68b6c5245ad24aa7aa54d72e55e38f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "buttons", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "17e30521633dca428f20f3714ef0547c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Paging buttons", + "_Key": "buttons" + }, + { + "$ID": "0cc978ec84c2464f83ae4be615bc4ff9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Virtual scrolling", + "_Key": "virtualScrolling" + }, + { + "$ID": "938b410c857a6042a44a30e9a49512eb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Load more", + "_Key": "loadMore" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "8341d37ae495ae42abc3af83721aef28", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show paging buttons", + "Category": "General::Rows", + "Description": "", + "IsDefault": false, + "PropertyKey": "showPagingButtons", + "ValueType": { + "$ID": "12b807bf2062554a9c20ad31add6e9fb", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "always", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "71b9ab80b8c2a34689663fe42595d53a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Always", + "_Key": "always" + }, + { + "$ID": "5d1c157d6fff3e43b9c3e50f03d45c36", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto", + "_Key": "auto" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "f03fe2d08d3c254e935b8410928a4583", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show number of rows", + "Category": "General::Rows", + "Description": "", + "IsDefault": false, + "PropertyKey": "showNumberOfRows", + "ValueType": { + "$ID": "4960188090b7d0429bfef1ac52a6b784", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "5c80536b76dc294eb3594faa917fcc5c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Position of pagination", + "Category": "General::Rows", + "Description": "", + "IsDefault": false, + "PropertyKey": "pagingPosition", + "ValueType": { + "$ID": "3dea683da585bb4da3530357896a1ce0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "bottom", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "f2ae76a9e30f644f96e2ddb41b1df44a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Below grid", + "_Key": "bottom" + }, + { + "$ID": "de62653bd0070647ab45f16c9d5a07d3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Above grid", + "_Key": "top" + }, + { + "$ID": "b8366c1971327e47ab14db36739f29a9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Both", + "_Key": "both" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "4b0d3b5a7fd86a4693fdf5d1532730e5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Load more caption", + "Category": "General::Rows", + "Description": "", + "IsDefault": false, + "PropertyKey": "loadMoreButtonCaption", + "ValueType": { + "$ID": "ac2068231713c24e85e10d4b5f776800", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "0ed769f4ba63e8408a6f649da30a3686", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Load More" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "9fb6378b75befa4ca59a93775fa0a9ce", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Empty list message", + "Category": "General::Rows", + "Description": "", + "IsDefault": false, + "PropertyKey": "showEmptyPlaceholder", + "ValueType": { + "$ID": "a4d1b7ee48c68b409305d48f73dcc25f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "none", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "6305edd7a1b46f4b9dcf2e4ef1fc67a3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "None", + "_Key": "none" + }, + { + "$ID": "f5ce3203019d8e4ab0d1cf5542e73936", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Custom", + "_Key": "custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "f59951ee2892fa4ba44509c9e6a21629", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Empty placeholder", + "Category": "General::Rows", + "Description": "", + "IsDefault": false, + "PropertyKey": "emptyPlaceholder", + "ValueType": { + "$ID": "8b211b76c386b546ac7a2d46705144c4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "35517a1697cc3f42976f9af8fa95ab8b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Dynamic row class", + "Category": "General::Rows", + "Description": "", + "IsDefault": false, + "PropertyKey": "rowClass", + "ValueType": { + "$ID": "b2709a701e01444dbd4fb2f622cb363c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "9fc7847f568c6a45bd01785b15e67b73", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "166563e60d0eb340be6725f56d80a88c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click trigger", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClickTrigger", + "ValueType": { + "$ID": "14fe185a5cb2c94aaffdeab94688d515", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "single", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "fbbe925cb434004890ea5c0b5a54e5d8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Single click", + "_Key": "single" + }, + { + "$ID": "975e730a2737804783c586f2444adb09", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Double click", + "_Key": "double" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "bace8d4d531ac54889c8b59cb8210dd7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click action", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClick", + "ValueType": { + "$ID": "0dc23c9b17707d4ab5bcda9d449e0b7f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "f83ae02956fdb743adbe7984a04502e0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On selection change", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onSelectionChange", + "ValueType": { + "$ID": "e905d2edc64e7a4baefd43dc311cdb2b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "31e885c4ac9ae54192f91ab69f1ff2a1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filters placeholder", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "filtersPlaceholder", + "ValueType": { + "$ID": "e5936adb5658f24894c090b16363468e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "909d13f0a578eb49ad680387b257670d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Sorting", + "Category": "Personalization::Column capabilities", + "Description": "Enable sorting for all columns unless specified otherwise in the column setting", + "IsDefault": false, + "PropertyKey": "columnsSortable", + "ValueType": { + "$ID": "26302a7e02a4cb49acf07346ce10f025", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "e4c0deacd41b7540bd9c96f158f5bd3b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Resizing", + "Category": "Personalization::Column capabilities", + "Description": "Enable resizing for all columns unless specified otherwise in the column setting", + "IsDefault": false, + "PropertyKey": "columnsResizable", + "ValueType": { + "$ID": "6c07108f87c0454cb78cfe3cb587cdb2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "5d3171e73a24f04a9f2c77710e71ca92", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Reordering", + "Category": "Personalization::Column capabilities", + "Description": "Enable reordering for all columns unless specified otherwise in the column setting", + "IsDefault": false, + "PropertyKey": "columnsDraggable", + "ValueType": { + "$ID": "b2d71c2f7cc03043ac244ffe50fa01f4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "ebc6591c4fb0bf4fad17b05bf0a91450", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Hiding", + "Category": "Personalization::Column capabilities", + "Description": "Enable hiding for all columns unless specified otherwise in the column setting", + "IsDefault": false, + "PropertyKey": "columnsHidable", + "ValueType": { + "$ID": "740fdcc0c162bf44ae40dce458984235", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "2ae5e75be87f1842975e8320999ea2f4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Store configuration in", + "Category": "Personalization::Configuration", + "Description": "When Browser local storage is selected, the configuration is scoped to a browser profile. This configuration is not tied to a Mendix user.", + "IsDefault": false, + "PropertyKey": "configurationStorageType", + "ValueType": { + "$ID": "47083097beaede40aa23d6d7797183b8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "attribute", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "d79bd5230601154da81e5fea44c0374d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Attribute", + "_Key": "attribute" + }, + { + "$ID": "d2aaaf378153f349b0422c3e55428e7a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Browser local storage", + "_Key": "localStorage" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "1cc181201f7e03419d40fcbd144c8e91", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "Personalization::Configuration", + "Description": "Attribute containing the personalized configuration of the capabilities. This configuration is automatically stored and loaded. The attribute requires Unlimited String.", + "IsDefault": false, + "PropertyKey": "configurationAttribute", + "ValueType": { + "$ID": "7bfac7af59629941960a6ade03a60db8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "onConfigurationChange", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "5db840fb93645840bacec6ff653b10e3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Store filters", + "Category": "Personalization::Configuration", + "Description": "", + "IsDefault": false, + "PropertyKey": "storeFiltersInPersonalization", + "ValueType": { + "$ID": "9b3ef0a7cbc927479335968bf2e5542a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "7d6383533e9c4b46b23d4e3c8aec1da8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "Personalization::Configuration", + "Description": "", + "IsDefault": false, + "PropertyKey": "onConfigurationChange", + "ValueType": { + "$ID": "0c589adf8f4e3242b2cbfb845bf92ab1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "7b0964a6da194047a81f9b8f6e701b75", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filter section", + "Category": "Accessibility::Aria labels", + "Description": "Assistive technology will read this upon reaching a filtering or sorting section.", + "IsDefault": false, + "PropertyKey": "filterSectionTitle", + "ValueType": { + "$ID": "5947021f6a3bfb4981539e169f497112", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "254673061cf31041aed804178e7f68ba", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Export progress", + "Category": "Accessibility::Aria labels", + "Description": "Assistive technology will read this upon reaching a export dialog.", + "IsDefault": false, + "PropertyKey": "exportDialogLabel", + "ValueType": { + "$ID": "08de029dc10e37429e195f060be7f402", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "6d34e792c523e844b1ab1e7a203a403d", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Export progress" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "964264b2c4d63e42ac3b38ac988d760b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Cancel data export", + "Category": "Accessibility::Aria labels", + "Description": "Assistive technology will read this upon reaching a cancel button.", + "IsDefault": false, + "PropertyKey": "cancelExportLabel", + "ValueType": { + "$ID": "af6ff4211003af4dbe1e71b20fb23de8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "6891de3825bd3844945ad1b937956720", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Cancel data export" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "1c1a586ccbee984ea076f89c947b3a34", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Select row", + "Category": "Accessibility::Aria labels", + "Description": "If selection is enabled, assistive technology will read this upon reaching a checkbox.", + "IsDefault": false, + "PropertyKey": "selectRowLabel", + "ValueType": { + "$ID": "f57bc00abd0a2e4ab02f990746323380", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "b177e773de20c84e88a4d2f64961cb4c", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Select row" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "cbbd3b4e95b020469ed526b760dca9ac", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Select all row", + "Category": "Accessibility::Aria labels", + "Description": "If selection is enabled, assistive technology will read this upon reaching 'Select all' checkbox.", + "IsDefault": false, + "PropertyKey": "selectAllRowsLabel", + "ValueType": { + "$ID": "76f271b29b5a5d4b9cd03cac7b3543fe", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "dabd5dd835e7e042b2fd0bd8581639cd", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Select all rows" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "20e90307d080394b92c32b31260000e3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Row count singular", + "Category": "Accessibility::Aria labels", + "Description": "Must include '%d' to denote number position ('%d row selected')", + "IsDefault": false, + "PropertyKey": "selectedCountTemplateSingular", + "ValueType": { + "$ID": "cdefe8dcf7964844984c8dc971208a57", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "a55ca708649be44ea3262603347d6438", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Row count plural", + "Category": "Accessibility::Aria labels", + "Description": "Must include '%d' to denote number position ('%d rows selected')", + "IsDefault": false, + "PropertyKey": "selectedCountTemplatePlural", + "ValueType": { + "$ID": "12e7ce23353aa94fb14c8218e8fece99", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Data Containers", + "StudioProCategory": "Data containers", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.datagrid.Datagrid", + "WidgetName": "Data grid 2", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "e6321006ef545f408cf010f25637baa3", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "dae87c3bd03a8b4fb463d5575c00d4f6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8e6dc61f82a9a544ac8d89566dd84e39", + "Value": { + "$ID": "5610ab4e45d0f444b9a402673a79bfb3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "72ee3feac81b564fa2a0b089a651120e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6f94cb2ac769164fbf2bd0a9fa6bac4b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "65d34bb55fc10e43978f69410d8505d4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2b22ef610db1a34d8d07bc9483939b35", + "Value": { + "$ID": "97ec7933cd0b0349ae5ae9a0bee200ea", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3dc323a203de754dafddc2bd7c56a422", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": { + "$ID": "775416dd9e63ab4ba96bc9fd693dced9", + "$Type": "CustomWidgets$CustomWidgetXPathSource", + "EntityRef": null, + "ForceFullObjects": false, + "SortBar": { + "$ID": "64f24869809dd446b4f59facf3f36597", + "$Type": "Forms$GridSortBar", + "SortItems": [ + 2 + ] + }, + "SourceVariable": null, + "XPathConstraint": "" + }, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "244f87de3808fd4fac538e15febc9700", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8d015d4117132a4c80d33ab36c2e442b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c336275df77b984b95b4d13b9d008bb5", + "Value": { + "$ID": "bb61916eaed7d74cb54fffc719d901b3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2459ab143734b642a189a8cd71f7d69c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "0", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "054188bdead2344da9de05b61a483cdc", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "454e0809f05ee449b70513b17754c676", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "eaba539f116f7342b3d8c54a49787446", + "Value": { + "$ID": "f5ce35bccb6e074d900289d6c54f06df", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2b589ab0a8a3a342b6d69b96108a9d2b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2e6b8a8d2647e641b0bfaf28a121a51c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cf1130d3886fa4459cd603da5fbd0f56", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5a51339ec4f5784b99317d8621c92960", + "Value": { + "$ID": "83fe4489d9b3f94cbce2af9c58937c79", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "cbd8787dc35d3641839c57a8893af6b7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "checkbox", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "36f02171758cf2498d840778b310f5a3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "fcf91b425d6d4242b48660e4ed5e5b26", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d9495be7dd3e5f44976bb6d0c39a32b9", + "Value": { + "$ID": "5c9c9304b98d944eb9552263f4ce421e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ae3484ca8ec45d42a6dee1ed09a9656c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "clear", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "da0e08557d42ce4497662067c8fe0e2c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4f272ce77eb3424ea79cc58d2578cd25", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e1bcad535ec16c418bff03e1c38954fd", + "Value": { + "$ID": "fc59ca9e9376e646839eded5b067a945", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f88c9a33bb1f5444bf4c0292c4bad502", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2939fa612d463348bfdc52be8ab31835", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b6583d937934984d968f8313ae858f20", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7b3fc1dd6948d34a99578293b2cf21e9", + "Value": { + "$ID": "78f791972b39884197b881f7ac099da3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "eae269a2ca4e0a428cb7674f6cf37ae6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "spinner", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9fd1ad2a9da5664a944321231bf97571", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c9b4c100ea14384baa024308ed9d9a77", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b25ffbc435d0a745ad48c22603f5bc4b", + "Value": { + "$ID": "0cc2077d12aefa40a7cb68d756cd3425", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a159713166311940988f7d48e836efc6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2, + { + "$ID": "41787c4aa17d204c82ca914e76cb1699", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "355f5340a8474944b2217f9a14856bbf", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "42b23beb7e4ec0419b0d4b9bb6808ea7", + "Value": { + "$ID": "bd4798666d700540acaf1869a0edbf57", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "38e0d6d117e70843a73743597f5d74c4", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "attribute", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d08468fadf9e8947b713dfc3031a55e5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cb08a5bfe65d2e408ccf044892a588dc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "19bc7fbbe39eb34eb060a709cfab3ed7", + "Value": { + "$ID": "b2dabdb85e741844841da3e763fda042", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5d875f0d39ab7c4bb522159f1545bc06", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "891d56daea68d34cbe0c861593256290", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "7906fd6da2c86d40ade04b5597582a8a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "709628f1195f9042a053377eed3be9b7", + "Value": { + "$ID": "017a875785c64d4cbdba62e281255661", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4ad12c108e80d24f8eb1f19863f9c838", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "aa67c6469eb18f4b98839c9ab3f9ba40", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2529d1f2b86f0740a111fd60b18912a0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3f0f2f5ea82d714f871e2924cbf48a04", + "Value": { + "$ID": "bd50762d3bb9a34da60bfa7534e70ad5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "355ca91f0e7b654ca47388a9ed83f328", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "31eeffd78901ee46a8d2dbb1096883ac", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bc1754ed47a9f64abf61b433077ac535", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "439036c51e60ff4ab7c48ad338fb2b98", + "Value": { + "$ID": "aa22d3b984270c41a27522ab71f63d84", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "885ed1719c537242ad18b240b36c02ea", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2a85a05a84266a40a8bd785f31bef5c7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "dd6f3a718a1101458dc12fec06bd6ffc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e814f7f0741e744faf7c2d19644b5ab7", + "Value": { + "$ID": "7b1c3b76569a2047b0dee742ba03544e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3d09c3808cde334ba87f8a9a4f1effa3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "c9e84eac9939d94786f3652e41c7e265", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "cef2a0150c2ebd4584c03a9c6941003e", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "9608c772849e0240be2e07e3bb9e2f26", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "ec1bce8cbafd23488dc4af88e1894c0b", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Title" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "3229189af9732148b9ccf0b2b8c4b54e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "412942bcdbc2784aa5e2827ddf646caf", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2c6165ee98ed204baa53bccbf70bb228", + "Value": { + "$ID": "8d7f6396c9cf8e42afa5db334110beb5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e0b633f5833fcd49b66088e20b167926", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "73c97228cb69a64aa55d6d7097422fcc", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "013e7a085588ac46965854f844907123", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "ba24d375b4328e4493510cc1edc7e0fd", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "8307088dfe9ae747821cfa38b39340db", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "37e5165e75b06e4fb229e4b158fd37c3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "64b4d33dd9fce547a00c94b1dcf4d6cb", + "Value": { + "$ID": "57c10db5b064b64ca6e3e6da93e365a1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4146322a6b98e84096bcf521fd9dbd79", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9289d2ade6b0a245b1ccc86590fcfffa", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ec1f8b563e7dfa44814cdd4b96074d9c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4a6f429cbc60944f9211f9298e0a0c28", + "Value": { + "$ID": "6cb1acd7b97df7428f5b27630a93d81a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1acb0c7e33d2024c8e1cfd94445e65a6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5b422d79d625a24bb7acb057f0cc044e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b971b3ac1d1a8a4caf6dfc320f96edbe", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6d2823abd5ff064096a10cfaa36cb62a", + "Value": { + "$ID": "b8b48964b3ead74fa80953c4f5306acb", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "865fdf3dea2ba64f80ba9af145d02b74", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1a3635856b495f4db370409a36d14de6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a21c1da412ca12479f56c37955baba36", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cc9a2bbc1c0ca84ba6b5d8d3d5e5fd6c", + "Value": { + "$ID": "00e43437121f55439ba54b7a14cc4670", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ee9ecfa3bc9a724580a444ae2c66f803", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b582b02df0b14b4e80c70e641ec1374d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a627a32425175945b0e2e600adfd6ea4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cb8fb2c675f14f4299bce269c1cd2942", + "Value": { + "$ID": "e7d6fb16c5c54e429daaf5bfb119e7a4", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5da6a13e213f104981de92b50071b5e0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9a8c88dc898a7c47a42e9799a3601b43", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "529053868e3fb140bdfcbd20bb92aae1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3bcd7d3aa449724aadfda0d46082e717", + "Value": { + "$ID": "2de9ad730d7b02418f66c38f7b3d8c18", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a0cbe2fa5fb1bb498946a85b83c9f883", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "yes", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e82e6cee19fc27458ebba7a8ae21496e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "3aaccf975905a3409dc4af745fb9d012", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3669ed18ca24b74aac9aaa695210a5c5", + "Value": { + "$ID": "aa8db8817810944096c0c032136eb4d5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "eaf6b01216701d4487ee94651791c118", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f5f0faaed054c84bb92adc30f3746487", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6d82db59935b124d996de23252f359d3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "368826bcdb056d4480e5955cdd4f44b1", + "Value": { + "$ID": "de9fec4f7920f94fabf493c45292dd1a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "687f263bc4a5f44eb73de0be67d30041", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "autoFill", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "62c0fc9c4e01e3438854084fb52167f9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "86d25fbb206ecc4a96b69e4df461650f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "92bb2d8ad8c41849b43246a7270cbc95", + "Value": { + "$ID": "aca31a20ae9f9b479e6fc482ea37f9e2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1d850f3fda4ac849912e8041b6b1054e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "auto", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2e3d7bd7ef8f8a46a03804eba5bd6765", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "05ad718f21302741a1b2c3c907804772", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3fc28169fdd8e848aa70ed35425f0f2d", + "Value": { + "$ID": "9b88e1b6747e4b48b994a2027aa9f983", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6ad8bede96bbc044907ffc95125145a6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1b36b872c581a14589a9223b58e11bfa", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5f220ee5790dfe43b1068c411285a60f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c60605f54797444dafbe51917a7711e9", + "Value": { + "$ID": "ad4f59ded109b94bae42c8222ce7c464", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "112250ab0c45564e9f34b3e291555305", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "1", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "25369751340a784ab6507e09637f05a6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "29c4d571d7db48418733ccfc372e39d8", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3be7976bdbc1834aa7cfada2585a71e7", + "Value": { + "$ID": "8a9cfb95fb2e1b45a79a31897567ab9f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a6e0c2d310df8f4da9fd228719436c3d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "left", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "65db3a93520f82408a833caeadbbd110", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "dd39fce604cf1741875b845f395816ba", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "78949d0fef5c2142b2071c125e2792cf", + "Value": { + "$ID": "62a46905dc32c24db81d72d750499c63", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d028502f423654419ca1d88dbf4f1002", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "752ba62b5ad0b4429f0ac27cb36a491d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0ebd1320164e2c448c8bc8db46ae9cff", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1138296ab096e64fb2a990d9850c5d29", + "Value": { + "$ID": "d293b3df96abcb48a96a4947beb33354", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7e90102e43ebb2408c95d0628a9192cb", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b97b4b7cd4d2b04cb9239e07c4b9fda4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "08a2e91acbe0fa469f51aad8e32e8c91" + }, + { + "$ID": "fa1f87efff9b384ebd921ca7e076be78", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "5376950c240d8144bea9ec66c8605564", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "42b23beb7e4ec0419b0d4b9bb6808ea7", + "Value": { + "$ID": "ed6e615fbf56914fb10a15f2f126582c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f61e8c0941bce349840da85d364f8e1a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "attribute", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d08468fadf9e8947b713dfc3031a55e5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c18b42e6d1375e4a8121c08e3788f827", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "19bc7fbbe39eb34eb060a709cfab3ed7", + "Value": { + "$ID": "4f43a2a778d6ce4f9cbcee5bec8d9a0b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c7f6bc469a3a384388899bddc41d5df7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "891d56daea68d34cbe0c861593256290", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "fcd0cce2a7f3e64f83de227d24153b6a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "709628f1195f9042a053377eed3be9b7", + "Value": { + "$ID": "1f0fa344c0ae5d4abaf06d23596bceaf", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8e72248995ae25479cdeafc01eac8b55", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "aa67c6469eb18f4b98839c9ab3f9ba40", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "21132c8abbb0754cbddea796bc0d71e1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3f0f2f5ea82d714f871e2924cbf48a04", + "Value": { + "$ID": "1258265076fb1f409c9467e5dab65bd4", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "176437901874ce41b6bf1ec71723988c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "31eeffd78901ee46a8d2dbb1096883ac", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "25fcc25fd5283e4f86ce5f7263f84c24", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "439036c51e60ff4ab7c48ad338fb2b98", + "Value": { + "$ID": "a0a848c3ba820f478cb2d5f53881653a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2bc30b85cced5b41ae15b78bc8bfaa30", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2a85a05a84266a40a8bd785f31bef5c7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d4d9b5747302c344b83b7592855e0eee", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e814f7f0741e744faf7c2d19644b5ab7", + "Value": { + "$ID": "b3417ef2c5c30345ab8c0c5adcb48333", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8d50781a33c7034791f8eb635a7b09f3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "98497200cad42146882d5905c25de898", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "4ec4f03448b8cf4ea13e99183dc4536c", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "c0bd48135c429e40ac5eae9bc1164658", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "e396ec4d0778f248ab72e7d015761e7e", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Last login" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "3229189af9732148b9ccf0b2b8c4b54e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4386c01d198c0643911ddc747b6cafae", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2c6165ee98ed204baa53bccbf70bb228", + "Value": { + "$ID": "34537944de06fc45aa24660071d3cf36", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b53edf6b4f51c645b2346a964154dbde", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "4b13c7841ecf224ba082c501201def3e", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "ddf4a605c47a0b4e90021cd0643781bc", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "86025f45a6bd3e4e830a02abd1ef6d92", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "8307088dfe9ae747821cfa38b39340db", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "53cb682f950d6f44b10b54f2c56da25c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "64b4d33dd9fce547a00c94b1dcf4d6cb", + "Value": { + "$ID": "8493b99f160b0246ba696362c8d68d46", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2cbc3599aee7a24aa51aaaab46991235", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9289d2ade6b0a245b1ccc86590fcfffa", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f510b84e29b890469355797c5e66f2ad", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4a6f429cbc60944f9211f9298e0a0c28", + "Value": { + "$ID": "df03808263dd0c428daa4efd45b35538", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2ff5892d84740e4fb4a2ae186dc217e2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5b422d79d625a24bb7acb057f0cc044e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "02738e8a515ad9458298c86d94f953c8", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6d2823abd5ff064096a10cfaa36cb62a", + "Value": { + "$ID": "b8b247255928324c9ee99f7f2e843ce0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "982a8a9bd602b549a56411f8cd4beced", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1a3635856b495f4db370409a36d14de6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "204016996ba1b6448ec4d9fe1a87932b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cc9a2bbc1c0ca84ba6b5d8d3d5e5fd6c", + "Value": { + "$ID": "a28cf8c8719d204680a047abb8e87c3e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b00da3aeed8a8741ab29a799fdfc5fb5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b582b02df0b14b4e80c70e641ec1374d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4e0917df576818438f83c619ebfbabd9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cb8fb2c675f14f4299bce269c1cd2942", + "Value": { + "$ID": "cd8ebec7399968428e0b194729303a1a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "34ccd1f3029c9643846ee995ff350670", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9a8c88dc898a7c47a42e9799a3601b43", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9468fad7ddfc674192efba5f252a5ff5", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3bcd7d3aa449724aadfda0d46082e717", + "Value": { + "$ID": "a5c158034fb4144fb8b0b280d839373c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "17a94056726537478ef5bf27f0941c18", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "yes", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e82e6cee19fc27458ebba7a8ae21496e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "7fc650f3d53622418e7b3e41d7144523", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3669ed18ca24b74aac9aaa695210a5c5", + "Value": { + "$ID": "34e64f65ad7d66408e2d842d1ee00ed5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f504bdbe960a3d4ba33782c20df9dd03", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f5f0faaed054c84bb92adc30f3746487", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "31d56df1114adb47848bd1bebab76e53", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "368826bcdb056d4480e5955cdd4f44b1", + "Value": { + "$ID": "46026a13ac012845a57e20574a021583", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "257c762f03f39547a1a0202da70c288d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "autoFill", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "62c0fc9c4e01e3438854084fb52167f9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "221457d7557ae347abe9ee5f255d9341", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "92bb2d8ad8c41849b43246a7270cbc95", + "Value": { + "$ID": "782a96ef46c03643817290f6e50eb4a6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "793af7e9fe64d14198e7fdc2f27ce374", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "auto", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2e3d7bd7ef8f8a46a03804eba5bd6765", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bbfe9aa99309cb4ebb6e1f8c62467323", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3fc28169fdd8e848aa70ed35425f0f2d", + "Value": { + "$ID": "ef820b38622896408134996f053ec2d5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "41aa66da99f7a14cb31d658a15c2bef7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1b36b872c581a14589a9223b58e11bfa", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "844fe66233779a489a25739ee9fe2f6e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c60605f54797444dafbe51917a7711e9", + "Value": { + "$ID": "9e3006edd0da1b49adbfbf24686b7774", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3bf815874fa4484897502c60b4f57376", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "1", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "25369751340a784ab6507e09637f05a6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d8bd74c6340d5b4cad1a93ff37a1e3d4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3be7976bdbc1834aa7cfada2585a71e7", + "Value": { + "$ID": "2958acd8cbb9b8458a32cd8df3ea6a33", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "240c5369b297db439bf16b34267d6bf3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "left", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "65db3a93520f82408a833caeadbbd110", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cb39b6815de5ca48969798495c2b4e5f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "78949d0fef5c2142b2071c125e2792cf", + "Value": { + "$ID": "b11ade99a72241419a52957608195f2d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "cb9ef02634dc4b47b646838ff0fb8861", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "752ba62b5ad0b4429f0ac27cb36a491d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "26f706c106d4c1458f2a6f4a6ec6aa8e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1138296ab096e64fb2a990d9850c5d29", + "Value": { + "$ID": "116c32016a06274eb06a60b1590bc777", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "79788763366a014b86be0e28ab918425", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b97b4b7cd4d2b04cb9239e07c4b9fda4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "08a2e91acbe0fa469f51aad8e32e8c91" + }, + { + "$ID": "f1075aae2a24804cb4713bf9cd32f30d", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "125934cf05420c44b086bcf1d09a8782", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "42b23beb7e4ec0419b0d4b9bb6808ea7", + "Value": { + "$ID": "383e79ae9e910a409e9289171939651e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6f7ef85db1700446a3773258b75b9e0d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "customContent", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d08468fadf9e8947b713dfc3031a55e5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5372ee91648d6c469eeca96e9630e576", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "19bc7fbbe39eb34eb060a709cfab3ed7", + "Value": { + "$ID": "cdde86315e96034eb0b4cde13666e88e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7558d4d9ae8a994bb50295a2f41eaf4a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "891d56daea68d34cbe0c861593256290", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "023f37d0d80d0740b9bf1cf1dc0fb287", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "709628f1195f9042a053377eed3be9b7", + "Value": { + "$ID": "19840a1be75af942ae1efad59fcf9a68", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6142f06dc6d8784887858f7c96130f97", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "aa67c6469eb18f4b98839c9ab3f9ba40", + "Widgets": [ + 2, + { + "$ID": "3759cc311012d64981d4e694376580c3", + "$Type": "Forms$ActionButton", + "Action": { + "$ID": "f2e239d8ee397e4fb633c9241664a3e1", + "$Type": "Forms$DeleteClientAction", + "ClosePage": false, + "DisabledDuringExecution": true, + "SourceVariable": null + }, + "Appearance": { + "$ID": "650a5c1600b85042a4d5f3c4d7b61d3e", + "$Type": "Forms$Appearance", + "Class": "", + "DesignProperties": [ + 3, + { + "$ID": "2a74c8156eeccb4ea6f3e942071e77f9", + "$Type": "Forms$DesignPropertyValue", + "Key": "Size", + "Value": { + "$ID": "9bc43d05c634b44d9bb80f84863646eb", + "$Type": "Forms$OptionDesignPropertyValue", + "Option": "Large" + } + } + ], + "DynamicClasses": "", + "Style": "" + }, + "AriaRole": "Button", + "ButtonStyle": "Primary", + "CaptionTemplate": { + "$ID": "7746263eea93b74dbd7e962ae2e0dfaf", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "f68c93fc91237e42a3bd8c26a445a677", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "893d8e556cf5b74781cbfe2da758ba7e", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "3f1d0118a63beb40b7b4418885a72e7a", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "" + } + ] + } + }, + "ConditionalVisibilitySettings": null, + "Icon": { + "$ID": "c3002444afdd4f4ab3df45eb84b146ef", + "$Type": "Forms$IconCollectionIcon", + "Image": "Atlas_Core.Atlas.trash-can" + }, + "Name": "actionButton5", + "NativeAccessibilitySettings": null, + "RenderType": "Link", + "TabIndex": 0, + "Tooltip": { + "$ID": "4300c17fb2cd3142bcbb228b417a6d40", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + } + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4a7ddd48ddf961428bda1e7df0e47826", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3f0f2f5ea82d714f871e2924cbf48a04", + "Value": { + "$ID": "fd05025960d3774887b8b8e53dc9ac42", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0333264a78f03a4a90329576e400e0e2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "31eeffd78901ee46a8d2dbb1096883ac", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "68635cd4eda8ce478118089cd9ec5562", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "439036c51e60ff4ab7c48ad338fb2b98", + "Value": { + "$ID": "71008ccfd58c834e9eab27fd3e13bd87", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "97e7cdb6317dac4bb5f486978f62bc5a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "19ef37ba09ce3547b3368790facf8a3d", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "f95e5e382d3df14ea929c42885e0934e", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "77dc1fb61469cf4f930ff57b6719600d", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "2a85a05a84266a40a8bd785f31bef5c7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2aa9492b1a2a5842a7abae18a6983b75", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e814f7f0741e744faf7c2d19644b5ab7", + "Value": { + "$ID": "2374c80c21166c428c2cd8781642918a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d0547fa51a4b34439b2b317aca935a7a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "b3fdabceb59e5445b0820dd68b16943b", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "2fd0aedfd88ea347b62639f0c0eaef5a", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "2772be4c46438449a178981385091923", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "3d3b57855c059444880ea73afe14acd9", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": " " + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "3229189af9732148b9ccf0b2b8c4b54e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e897514c25555e48b280a600b6312faa", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2c6165ee98ed204baa53bccbf70bb228", + "Value": { + "$ID": "3cb68c69a7bb1c4286dac70dcb98b2ed", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "20a6251937b28543b628a4803d92399f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8307088dfe9ae747821cfa38b39340db", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8e8d63c8cc9ea448a662b5d4394b8220", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "64b4d33dd9fce547a00c94b1dcf4d6cb", + "Value": { + "$ID": "966b5d31675b1843b61080b2a6b1010f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1b24199e835e314c8b55ed5bbc4e26d9", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9289d2ade6b0a245b1ccc86590fcfffa", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f2760e8bc9c3d94cbd293eb7fda313c6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4a6f429cbc60944f9211f9298e0a0c28", + "Value": { + "$ID": "f9b80ba242ac2740b38a83a11170cd72", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "09e7f5a49aa2a74ab98ef97a77770505", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5b422d79d625a24bb7acb057f0cc044e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6815354146f5f94dac51c49c771c9dbe", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6d2823abd5ff064096a10cfaa36cb62a", + "Value": { + "$ID": "8398029cfcaa214faddb35f2bd20615c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "54f87e7059624641a3ad57403b80638a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1a3635856b495f4db370409a36d14de6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a5262a7d1a21f44892039cf51b8d0884", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cc9a2bbc1c0ca84ba6b5d8d3d5e5fd6c", + "Value": { + "$ID": "0849f2df04ef214e899dbb20796e1d0e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d123d7fe3de591439cc63be31bfda9c3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b582b02df0b14b4e80c70e641ec1374d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4aa5bcf39b6c214cbdd43b10bfe993a0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cb8fb2c675f14f4299bce269c1cd2942", + "Value": { + "$ID": "6b2adadca889ff478eee98b542a9c24a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "42583ca9c5ecf2498ec90b0b545558f1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9a8c88dc898a7c47a42e9799a3601b43", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1944097ff347494fa8f6839432a5fdf9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3bcd7d3aa449724aadfda0d46082e717", + "Value": { + "$ID": "6ad958486ee97b43aca71130b0314b3a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3d79a87b322e2e4798934c8aa735043f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "no", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e82e6cee19fc27458ebba7a8ae21496e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "05173c44f510da46a1a3759be5bc682f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3669ed18ca24b74aac9aaa695210a5c5", + "Value": { + "$ID": "bc6c90da5f78954aa6145f926100cdaa", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b26ad9c5b68d0749ac0c2d4f6232fbe6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f5f0faaed054c84bb92adc30f3746487", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "58eab294cf28214fa244e6e1f4990993", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "368826bcdb056d4480e5955cdd4f44b1", + "Value": { + "$ID": "b3dd5e34bf9b7945916d6cca606a06f4", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6a2152f00c900a4f8472de5a7ad055ad", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "autoFit", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "62c0fc9c4e01e3438854084fb52167f9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "65f1f746f8a0194383950b2ce28e1279", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "92bb2d8ad8c41849b43246a7270cbc95", + "Value": { + "$ID": "ac3264dfd3d05b459b870303819ab024", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a3a6d93355e03b49be7de4447132ba8a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "auto", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2e3d7bd7ef8f8a46a03804eba5bd6765", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2b2cdb659b2c844b8bf39e9ad4de2ce4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3fc28169fdd8e848aa70ed35425f0f2d", + "Value": { + "$ID": "63f9431474a5e14c96a0eb5b1fe6b610", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ba31e35a3b8c984eae84f0c8be110010", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1b36b872c581a14589a9223b58e11bfa", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1fe5c580209bdb49a9ba7689d56e2407", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c60605f54797444dafbe51917a7711e9", + "Value": { + "$ID": "9a62847845371846bfbd6c64b07551ae", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "de77d0250141ec4093dac6e8da981ede", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "1", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "25369751340a784ab6507e09637f05a6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a21f557570b34c49a3d7f616406f7776", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3be7976bdbc1834aa7cfada2585a71e7", + "Value": { + "$ID": "15feb68a540cfc41a2637bad5e4db1fe", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "63c71b09a3f6a54b8a7a79ba5e14e5d5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "left", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "65db3a93520f82408a833caeadbbd110", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "21004b77cc82734f9282df0fa99933b9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "78949d0fef5c2142b2071c125e2792cf", + "Value": { + "$ID": "407bd5fe90553447be095f2879585c14", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "755ce0da45e1b846a59a11f0367f7174", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "752ba62b5ad0b4429f0ac27cb36a491d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c342f0414b93664a92f3bc17f1c7bc67", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1138296ab096e64fb2a990d9850c5d29", + "Value": { + "$ID": "66bcec7b0a86dd449d3c37101836a583", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1d8a68cff91a69448725a8f00b09ed6d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b97b4b7cd4d2b04cb9239e07c4b9fda4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "08a2e91acbe0fa469f51aad8e32e8c91" + } + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "80f04496ab45374ea73a77fec76ee303", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ba6022a855439e4fad86b5f89df83e2d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c8a4595e65efd94d9496d3914acd7c5a", + "Value": { + "$ID": "6e17e4e8074cff47b9436dd8010477cc", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "185ea679d21c2d478926905c1996b284", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "eab5c3373837c34ba225bfee65a59b55", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d103e8795258a5479d5bf6a6fae30b20", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "86b4a7024b764c4295a2f58565254cbc", + "Value": { + "$ID": "14d074dcda2e0f4395790a9703816a48", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6a73f0ab2c6dc84d846db9133348cde8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "20", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "bf6726c0e92ef54d8032a5447526f8d4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ab25b54725352641952f92623e838cb4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "54ab01ea8616e44fac53cfc21fa43ffd", + "Value": { + "$ID": "9e97637fea393545abe256c187ed284e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e01bc63049b12644b411c4f6329e5271", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "buttons", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4e68b6c5245ad24aa7aa54d72e55e38f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5a6c72f2835d724a8c3a5fedb6266cd1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8341d37ae495ae42abc3af83721aef28", + "Value": { + "$ID": "b76887aa73032e4b9302570a323502e1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "237f4613cc1e7545a22f728d4da05cd0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "always", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "12b807bf2062554a9c20ad31add6e9fb", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "74b489e4d0a5ba45ae388ccc696fbac4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f03fe2d08d3c254e935b8410928a4583", + "Value": { + "$ID": "9e77a885ec054341b011ca4333f72b6e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "87c514a8a358c84cb49f39cca9328f4c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4960188090b7d0429bfef1ac52a6b784", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b49e4403f2a95f4bbec4540e684bcddc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5c80536b76dc294eb3594faa917fcc5c", + "Value": { + "$ID": "399ba5ebc2b6f044882462c4e9166c55", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2869aca6d6dcf14d83bc69ffd00957fc", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "bottom", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "3dea683da585bb4da3530357896a1ce0", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "59aa7e0e2bbe8341a29b89128b65fc8c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4b0d3b5a7fd86a4693fdf5d1532730e5", + "Value": { + "$ID": "dde6c523e2f7434e8480de0b313d330f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a4afd438a3069443b4119fcd77eb4066", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ac2068231713c24e85e10d4b5f776800", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2ffb208ead73814b9c74d9624cd49b8c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9fb6378b75befa4ca59a93775fa0a9ce", + "Value": { + "$ID": "cd5ce143fa140b4885fdb5c32522abc5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "047e92654f1873419a26a370b3e3e1ba", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "none", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a4d1b7ee48c68b409305d48f73dcc25f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "480dc98cc3426c4ca664154332f2941a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f59951ee2892fa4ba44509c9e6a21629", + "Value": { + "$ID": "c34afab6308c964980bdb696cb8e0ea8", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e2dd0f09f9e1ef47ad987e771ce117c4", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8b211b76c386b546ac7a2d46705144c4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d28f72fb44db8d4ab8f69200b3023045", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "35517a1697cc3f42976f9af8fa95ab8b", + "Value": { + "$ID": "35528d4138839a49b2ea5dee4c910e33", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d33e716205b5ac4287b7f3263a59a289", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b2709a701e01444dbd4fb2f622cb363c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d8d32a5640409b4ab2e3d2827b2eb907", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "166563e60d0eb340be6725f56d80a88c", + "Value": { + "$ID": "9d30294b9b35574b9d88d8fcd6b1fad2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "de1492d9e4ad2a42ac0c84c985f6910e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "single", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "14fe185a5cb2c94aaffdeab94688d515", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f59f0d02d51cb44787d9dac7de6016c4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "bace8d4d531ac54889c8b59cb8210dd7", + "Value": { + "$ID": "6f4324b2e6b0b6479b886afd6c38cab9", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "493c9ea6e309c0458464d94596d65499", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0dc23c9b17707d4ab5bcda9d449e0b7f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ddd90d0127d05048897c9639d81c0ae7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f83ae02956fdb743adbe7984a04502e0", + "Value": { + "$ID": "2603c50b0b03734899f903658bde556e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8e1525cb1aa0f5479e19e09fcfe4243d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e905d2edc64e7a4baefd43dc311cdb2b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2062eb98399e3c48958c497f7e1934c1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "909d13f0a578eb49ad680387b257670d", + "Value": { + "$ID": "590f65f75064db4ebe0b4f9725450960", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b36a8b5631477c4595d1c7fbb4244ea1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "26302a7e02a4cb49acf07346ce10f025", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4547a61abd49fa4091b764573cd6ea32", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e4c0deacd41b7540bd9c96f158f5bd3b", + "Value": { + "$ID": "927327d84b9aa6478b16d12b97e13a3b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e8458aa12a4eb4459d17d85a14cce3e8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6c07108f87c0454cb78cfe3cb587cdb2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ce6a45867ea7824db093e5a4e6fbf4da", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5d3171e73a24f04a9f2c77710e71ca92", + "Value": { + "$ID": "02fbcbd1fc7da0458aea21cc473d360f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1e31020552e2b143a1d7ea3eabf4b776", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b2d71c2f7cc03043ac244ffe50fa01f4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f2cb00d4d28b3646ae8a67329e4d72af", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ebc6591c4fb0bf4fad17b05bf0a91450", + "Value": { + "$ID": "f3f699aac6b47349bfef142c088c3069", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7079fbeee3b1d8428164aa848fcc6d91", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "740fdcc0c162bf44ae40dce458984235", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0a23432473ca984e98970c54b0de09f2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2ae5e75be87f1842975e8320999ea2f4", + "Value": { + "$ID": "b236c7827f25574ab8ddd16193a11e99", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "49675ccdcabe434a8cd6a89cfe9ac607", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "attribute", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "47083097beaede40aa23d6d7797183b8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b8cc5a8ba60be543b4fd3f66203adf6a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1cc181201f7e03419d40fcbd144c8e91", + "Value": { + "$ID": "3c40c2f0cd92d14190ede9f103e78a1d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "62c4fca9d0a71149bb7b15f85d153f45", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7bfac7af59629941960a6ade03a60db8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8330969022ed5744b7cdbad5d0f4a2c7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5db840fb93645840bacec6ff653b10e3", + "Value": { + "$ID": "575b19029cf96a4c888dc8b5fc94286f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e5bc2783cd26fd4383a38ba74694e09e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9b3ef0a7cbc927479335968bf2e5542a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "df541f0990c328458c76d7f73ea58fe9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7d6383533e9c4b46b23d4e3c8aec1da8", + "Value": { + "$ID": "a168d9627723c74287568b2196dc62d0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f2c3e2ed0495d342910b117c5020e75a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0c589adf8f4e3242b2cbfb845bf92ab1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "93159d2031df14489b5fa4f34e86fc56", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "31e885c4ac9ae54192f91ab69f1ff2a1", + "Value": { + "$ID": "43db9244c5082046bb4d327b33e83f1c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "aaf308f7cde75540874cda8d99b94f16", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e5936adb5658f24894c090b16363468e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "fc83c85c2a037b46bc4778c71f9a2da0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7b0964a6da194047a81f9b8f6e701b75", + "Value": { + "$ID": "4b6e4f3eda03224687a2eb477faf4cc2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7a3ad91dc562d540b0570bbe10673bc1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "90a803dcdd2dde4ab5b8acffb319f29b", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "6d176892e1c9b547963dd6750d1b198c", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "4877a72583d18f4b8970718dddad4609", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "5947021f6a3bfb4981539e169f497112", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b1e6740366791c40979380310f05f47c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "254673061cf31041aed804178e7f68ba", + "Value": { + "$ID": "aa385cc5899f424e9ca11bc1ad62e133", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8c9a3418bda7804cb64b7e604b3040a8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "4a4d86a799bd794fb3a71999825a97ba", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "32f192d552a5c148a89600abf398cb83", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "e008df0d057cd948bb3f7767bfd86a99", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "95033d49c072c241aa33d2d79560b53b", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Export progress" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "08de029dc10e37429e195f060be7f402", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "00a6843571c2c84fbb853fa0832fc677", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "964264b2c4d63e42ac3b38ac988d760b", + "Value": { + "$ID": "d9b627adbfaec941b48cfb7241ae740d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a2fc19bb725c1f49935f81e52f365271", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "46dd01c4e8c57d40ad80c7a36475750c", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "906a827f67b0014f8ae0861b768d5c7a", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "20256dc01dc776409a616d41963e7f61", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "cc13ddbbc1f5514c898bc91b7557bbce", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Cancel data export" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "af6ff4211003af4dbe1e71b20fb23de8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "125f064189f5e24ea16c2affe480b334", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1c1a586ccbee984ea076f89c947b3a34", + "Value": { + "$ID": "d667b6c72e63704c9ae96a536d953006", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "17d53eb1defc8649b4e6f647f059507f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "1290b14426946f4faf9ecc6df4aa6eb3", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "63d4ae8e3b31c14d903704d7582b34c4", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "5b60ae278003a942b7f7d1120f4455dd", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "c02b53fd8b1d814cb37ef6bb89b2041b", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Select row" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "f57bc00abd0a2e4ab02f990746323380", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "850d3aa65016d0499f2a5b139f3589d3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cbbd3b4e95b020469ed526b760dca9ac", + "Value": { + "$ID": "fb79aaadd1f69047ac87e013540e829b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9c2608d761374240a7756cecc002b837", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "b9175233ab7b784383edcab133a8ee54", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "6cec512facceac46847fbc864d7121b7", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "7b49d8b834cdf843a2bf86a61b22775e", + "$Type": "Texts$Text", + "Items": [ + 3, + { + "$ID": "4ebba6dc264fe14a9ff9a6cde09d4fe6", + "$Type": "Texts$Translation", + "LanguageCode": "en_US", + "Text": "Select all rows" + } + ] + } + }, + "TranslatableValue": null, + "TypePointer": "76f271b29b5a5d4b9cd03cac7b3543fe", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9aaf4d38e23f3d4db8c473ec11195fa4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "80d67ae2e93ed0429ea102f1d80cc249", + "Value": { + "$ID": "6e1fb68e72174240b790f0b73607baec", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0b20adae136dc745bbfd81c071386b5a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1d242b405c836e4683ddb27e5e7df6ba", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "98eb47e17f3fc846b07affa3dce02aa5", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4386087aa57f3a4491639ab7be4ed3cf", + "Value": { + "$ID": "b37251a107cad14f8f7d03448441f85c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "651600e8c17d7747847c20bffbecbc41", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "34643e1f3bff584cb6f830b7d760a3d2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8f397b483ba386419450eb32b8244bdb", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "20e90307d080394b92c32b31260000e3", + "Value": { + "$ID": "3e9956efc4622e4c9469de4681c42c3a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "bce261e812edc44291c40177c188c0ae", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "2e3890be9b78d24fb7bd682be4594137", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "3d31e84ed1b2594398d108a9007fc79e", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "01d684c031750b42be774c83f3a43e2c", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "cdefe8dcf7964844984c8dc971208a57", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "357d9af7f6959540b7b066fa9ff83bf0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a55ca708649be44ea3262603347d6438", + "Value": { + "$ID": "1aedad1afe191d47ac552efd7451439d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "74b682a7f90ce64586d2e9f43454e97e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "49075d8b41d1e64da519b8eb6d472c46", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "000b6719d93db34ba0432b8be8a863fa", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "64b691727d16a3449f788a10e4b54fc6", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "12e7ce23353aa94fb14c8218e8fece99", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "dd790ecbaa33e948981485dacb8e9d85" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/dropdownsort.json b/modelsdk/widgets/templates/mendix-11.6/dropdownsort.json new file mode 100644 index 00000000..b8762e43 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/dropdownsort.json @@ -0,0 +1,639 @@ +{ + "widgetId": "com.mendix.widget.web.dropdownsort.DropdownSort", + "name": "Drop-down sort", + "version": "11.6.4", + "extractedFrom": "3e6abfe6-e8c3-4838-b48d-cdd7f8b149ca", + "type": { + "$ID": "b8d2cfee37f041bdb27d0f52e1c441ea", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/modules/gallery#4-1-drop-down-sort", + "ObjectType": { + "$ID": "120d8afba5974cf99e480a01d4d08435", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "f1317b894e584171a81633aa5933dbad", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Datasource to sort", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "linkedDs", + "ValueType": { + "$ID": "cba23601493c447789c45b4f6c4896f9", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": true, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "18e941e4bc844383bfa790bc44a02e55", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attributes", + "Category": "General::General", + "Description": "Select the attributes that the end-user may use for sorting", + "IsDefault": false, + "PropertyKey": "attributes", + "ValueType": { + "$ID": "9106343841054369a847e4227361ffd2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "e4db6891f0d44c17bc6d89da43e91c44", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "17d9dc1382384ee8b29bf93cb31451a1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "attribute", + "ValueType": { + "$ID": "6ac38d55045f40fda4e9c1716898cb9e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "AutoNumber", + "Decimal", + "Integer", + "Long", + "String", + "DateTime", + "Boolean", + "Enum" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../linkedDs", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": true, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "8dd13272e9d34c51902fad4a019c7200", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "caption", + "ValueType": { + "$ID": "afd5231dcf7f4bba9f29cab873884270", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "7c6936425498455db0dd42a47af5677b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Empty option caption", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "emptyOptionCaption", + "ValueType": { + "$ID": "7cd7cb7785854635bcd4cbebfcce2627", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "7bfb6190781e477ba2b17c8aae1e9b83", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Sort order button caption", + "Category": "Accessibility::Accessibility", + "Description": "Assistive technology will read this upon reaching the sort order button.", + "IsDefault": false, + "PropertyKey": "screenReaderButtonCaption", + "ValueType": { + "$ID": "24868f84769c47fdaad17c819eebabbb", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "39aecd9929a341288d999dacf28076c5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Input caption", + "Category": "Accessibility::Accessibility", + "Description": "Assistive technology will read this upon reaching the input element.", + "IsDefault": false, + "PropertyKey": "screenReaderInputCaption", + "ValueType": { + "$ID": "d505fbf7f4144d26b944fbbb3beeca02", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Data Controls", + "StudioProCategory": "Data controls", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.dropdownsort.DropdownSort", + "WidgetName": "Drop-down sort", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "c1b4ad6d38034c52b74aeb8321d63091", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "097120e02eca4ca78fdf848b94c4484e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f1317b894e584171a81633aa5933dbad", + "Value": { + "$ID": "8b198bf471624db7940bcefef66005d7", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8921998978db44bf82a6e8a4d8296fef", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cba23601493c447789c45b4f6c4896f9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f9c6726497d343259c6ec029c16fa391", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "18e941e4bc844383bfa790bc44a02e55", + "Value": { + "$ID": "9f9855fa934b4ab9be85e68df7e27131", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b5cf12d2ca664a3a9347991da7095b1b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9106343841054369a847e4227361ffd2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "71777e7b80a6489a910d127dafd81011", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7c6936425498455db0dd42a47af5677b", + "Value": { + "$ID": "32f3f1b2257f4c2796ff09844df4ee65", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3e8d720c804b4073bd8c6c1c4fc6e72d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "002d5e7109054cceb5b89ebb55290a0e", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "0d7965479ba34d85b87a7f13f092d38e", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "e4a06a73e1154e78adc9d60429f59ca8", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "7cd7cb7785854635bcd4cbebfcce2627", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "7ad2f4ea70064eb5bf3714e96e71f827", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7bfb6190781e477ba2b17c8aae1e9b83", + "Value": { + "$ID": "c089d516ebdf4f87b40b75cfe2e9a3fb", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6a30f33b302f4037a5abc986fe5efff2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "df3430a3658a44f68640966c1df833e2", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "02f7fb8b26aa4c14beb2d2424d3e9f0f", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "8080d89f48c04b07ad59ce605010f4fb", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "24868f84769c47fdaad17c819eebabbb", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "919216cc133d4a5ab1dc19789bee5b40", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "39aecd9929a341288d999dacf28076c5", + "Value": { + "$ID": "8dd70193e57a4613b7580425a9266718", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "72275b3561484e39a4de1ae0cf4a2286", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "663075078d7b4d6fa11824b14ce9a66a", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "3f91a97ea8de4532a4bdc80681fad4a9", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "bbd4b555ca4e45189d3dbe7e272d4933", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "d505fbf7f4144d26b944fbbb3beeca02", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "120d8afba5974cf99e480a01d4d08435" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/fieldset.json b/modelsdk/widgets/templates/mendix-11.6/fieldset.json new file mode 100644 index 00000000..cc4b7158 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/fieldset.json @@ -0,0 +1,377 @@ +{ + "widgetId": "com.mendix.widget.web.fieldset.Fieldset", + "name": "Fieldset", + "version": "11.6.4", + "extractedFrom": "c7be9537-45f5-45aa-92fc-ed052b6bc496", + "type": { + "$ID": "57f63fba7eed476ca88ec2a7a111615a", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/fieldset", + "ObjectType": { + "$ID": "5b8c60c42faa4be6b21a505fe61ab011", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "30701ee7121e4b00b8e989357cc518f1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Legend", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "legend", + "ValueType": { + "$ID": "61a0d2eb60e54d4eb5531cda780f8527", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "cb9f346f01e242ac99e160e81301e58c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Content", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "content", + "ValueType": { + "$ID": "0d4d0760e07e41198451e55e1c765956", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "5a53214b2c7b4498bbe330648d2a272d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Visibility", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "942420ac761f462d823138582bfa2e6d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "60b78f670fb847aca1db6cf27c3f81e5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Name", + "ValueType": { + "$ID": "783e577574304b8f813556471558e25c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "c3e4042892474f00beab3314c88ee89b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "TabIndex", + "ValueType": { + "$ID": "66c4f0b8294a4000bdb104d918b8f1d4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Input Elements", + "StudioProCategory": "Input elements", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.fieldset.Fieldset", + "WidgetName": "Fieldset", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "ba3c16b1e3624aa983bdfa5604ea1df1", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "4b07816381454d91ae4984d53244b6b4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "30701ee7121e4b00b8e989357cc518f1", + "Value": { + "$ID": "7c1c9436296348d991a139024bdf5bb6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "30cb1e0eff6a4c36997a1f1c35a62f9f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "6b5582a828044a92958cf61cf2f72163", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "d430d87568bf40a4b5a859c118ecc767", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "04a70387bf11476e832e71b7699eca88", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "61a0d2eb60e54d4eb5531cda780f8527", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0d18a2f006bc4d00aac5876e6d73557e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cb9f346f01e242ac99e160e81301e58c", + "Value": { + "$ID": "e8a026251eb34eea81f89bd9208803ea", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "89ec9566217f4928bc16e5e8c6c2b3ae", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0d4d0760e07e41198451e55e1c765956", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "5b8c60c42faa4be6b21a505fe61ab011" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/gallery.json b/modelsdk/widgets/templates/mendix-11.6/gallery.json new file mode 100644 index 00000000..350f9590 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/gallery.json @@ -0,0 +1,3118 @@ +{ + "extractedFrom": "17ec364c-ac1a-4790-9859-8580f0278d47", + "name": "Gallery", + "object": { + "$ID": "9b0cae7d97294fbf88abf3cafc51ee54", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "2d9fecb139364f90b5466ed31d46f4f0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "31b0a9721089471abe1c08cb8cdb5ffe", + "Value": { + "$ID": "548122aa888a40d0bbb15e8ee6bf9bc3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8d356407cdcb4c489b3d1f724bab3af1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d6c17d7292f34211b20684b4a38725da", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "978db1dae38948368fbb8459b78deb0d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7b02df9d9e5c42f4a658ce6044dc12b8", + "Value": { + "$ID": "40b49664f244455f834e184b4c53da12", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3b9069e924fb49c39df1b461751170a3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": { + "$ID": "1e4694c2700d4a5da47f590dc70517e9", + "$Type": "CustomWidgets$CustomWidgetXPathSource", + "EntityRef": null, + "ForceFullObjects": false, + "SortBar": { + "$ID": "19fd730b1ce74ebd89e6535328b94913", + "$Type": "Forms$GridSortBar", + "SortItems": [ + 2 + ] + }, + "SourceVariable": null, + "XPathConstraint": "" + }, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "bb30b0cf807d447c8b412fe11f812062", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6e2f1a3b890e4cbea66637392a14ac90", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "58f38ab267564da9b78fe179190a392a", + "Value": { + "$ID": "51cd4de0142146988760ac5be10c77ff", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d426d6ce03db45129c257cbe3a35e8ac", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "Single", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "492aa01efc0f4e7e987134391a6c2a2a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "10c3c8dc450b48b8af4a2b23708893ec", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6509b8c61dbd4485897d8b0929aa3d15", + "Value": { + "$ID": "d53b7968c2fa4c8eb5b7370f3399f6cf", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3e0452d1554342c1ae756ac4d6428ebe", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "clear", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "405c5594324241198c7d8ec673ea2626", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "11d02208132b4dad963f932913813310", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f929496fda154e9ea5a0bee0c8055fe9", + "Value": { + "$ID": "68aa9f594e2a48b9bc9f32a787e9575f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d4bb8ac9a1214c83b8226b09b82d7639", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cfc0f50efae9455cbbd1f6d06c97cb19", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c789d8f25d8040a2a7a3de5fcc2d0256", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6c97ba7e6cd44dcfa7d7ec4fe98d5918", + "Value": { + "$ID": "6285e926f1124d19afe65770938f745a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "aca8773ba0634335b9dd8b4db198da95", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5cadb97bf49546a5afaee593b6d2f398", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bc1a40353e774ce3bf8362e0f5d4c664", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d5311097fe25421ea154aa10b878a98f", + "Value": { + "$ID": "12f2d94b94e446929827ade58d9af522", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e107f8a55e1a4f27a7fef7df4455ad21", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "31d9a35c3e974c0ba74882887b4d0f45", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "10c439ba66de4fcabcbfd73785692969", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8f340a34ad2a4324a78d68aeb7c9c882", + "Value": { + "$ID": "779c2aa22e1e4950b3cd3ebfc8da8fa0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "91432b563b3943b28876e8dd2b64e9a7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "1", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cf9eb5e4f3b14cfe8c0e37028c942ac7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "45d5241ffd234f2f8a2379d7af8d772f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "04f980cab72c4affb41e02d7e4af34d7", + "Value": { + "$ID": "b9fd1db89e8a4e39844a389301f65e47", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "79c6ab0b8dfb40f6842d5c593c3aa7d8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "1", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "660d46ce13174f57b1c66ca48734b0ed", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bb544312749a4abdab30d8ff36e3fa6f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "0b0a9ffd0f1a4ed5a241f25bcf2bdbda", + "Value": { + "$ID": "65144c048fdc4100addba7388cb5544d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "781dc2eaad804b64aceba76669cfe7d9", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "1", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "3ddf7e99ae424a058abb511b1a5ca407", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "84a2432e08df4502b8b961ad5c91627a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f2473f5cde00484ea9e49c1aef65ad94", + "Value": { + "$ID": "244dcbbbb2be403a99126dcd3b646508", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "32e06175895849a991c9881f8e6f61b4", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "20", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "14208c2884f74d6e80f38452433fe656", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c5988dd60a7e43488640d6336c9d2241", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "fc6e9c443b194c2aafa7ea730bc8981b", + "Value": { + "$ID": "b0d89de539f34c1ca1e6b9fca6399dde", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c48a9d6b632f4cd1bbd0f43d53542353", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "buttons", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1982af8c020d4130b51381a095cf70bc", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9f0116408ddd4c8eb0b86ca018de6b9f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9d8ba4410ec741428ad3b687d85ff01f", + "Value": { + "$ID": "6e6f5f71b8f84eaab4d6a4f6b78aa3dc", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "845318144de143c38e1d052c65eb7967", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "99bd880b563146ddbd134b24e349184b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0742f3faf1114ace990a227a43d7e0a7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a375ce9727114e87a9d6f9f99f2ab273", + "Value": { + "$ID": "b58bb99d9e1145b686bbfc2808056464", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "82a1bb11d698446aab6e2dd4aa3f7d4b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "always", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "88f8002d05e447c1a05f9cb26d62452f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0f4d347203864f1c9386bc7c9b4fbd06", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4d33e089d6674b03825cd502cc3cfbc0", + "Value": { + "$ID": "93a043e1a1bf496d869be864180549e4", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0ca5a5004b0b40efbc244d0ad2d02dae", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "bottom", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f0d7674deea345deba27b38afb8623b6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4b8878b2e4514c52958ca6d0d2ef18b0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "32a8013811444fc1bbab8658a9320748", + "Value": { + "$ID": "3be01495d7f3452486b618d333d84744", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e1df5cb8883141ed84e2e814f54c258c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a41df587f3ee4577984a619e2492155b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6a7936ac75a9442a8ec9c166789c5186", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b53bbbd25d9a453f9dc8e243d6cd91c8", + "Value": { + "$ID": "19c67435985c485e907f716eb4ebcbf2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c7887ff3e7574193bf2145bd7628c1d7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "none", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "bdc82f03aef74c3dbba1bbc3466661ef", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f227deaf9b9548358495260d9cf657b2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ee55b425bb8042dc9d2c8212b7b4cd70", + "Value": { + "$ID": "c11646ac52774b3ba3879038827c73f9", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f59b4ec6ef2f4d459f61517ed98a928b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e387c1970f184dd6881a3f56cbebe141", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ad65637df42d4931a4cea5ede38e3e6a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ecf8d48a9990406cbc6d46c96972eeb2", + "Value": { + "$ID": "88ccd48657024842a573bce2743f0ac3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d9020b984fad41acbc8396113444c613", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "37e4f35bbd144641a2c85547d55ec82d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "3ded206ffec447bfa791504b6d2bb1a9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7b4c9566e96b4b028786d3eb9e481c37", + "Value": { + "$ID": "3eb7cabfb2d948e292dae679389466fe", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "66bfa6155a254729a3d275ab56d21959", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "single", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0dd3285dccee4455b7d4529c8205b09d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ea914d85907444ff92fdf0fa8939f8df", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "41affea39a70496eacc65f9020a7ca51", + "Value": { + "$ID": "aa3384db5a634ec1a6cc9f3314f1f567", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a76c1ae13ddb4900ae364fc9aec3c31a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8bca76ec55ef446bb8920f78b45fb81f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "74fdc1e204fc4769b7f399990669c333", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8900de019370404c8ad1c2d7d2c91083", + "Value": { + "$ID": "546ff5573afd4e61b78a6ec5f2489c7d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4f92e33d9f094aa7b90cf4b1edbd1167", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "99e8ceb69ae7404093f14ee2178d30d8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d7b02ced43a1433fbbc6859f6e0f22e6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "012cb6be356041ed8b4832e7b5285435", + "Value": { + "$ID": "237c6a41be29491db5ac756d31621420", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7475478b5c054136b33185a28dbe9aa8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "attribute", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "dbcc5f5ce880497ea86cd6124f790b6c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2ab44ab98b144e8091b01abfaaff6221", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a9bba43d45524fdebc5646cd21825fa5", + "Value": { + "$ID": "48a24e5942bd4bb8bc58601eb6c34ebc", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "42697b766ef5484396294ae151132d7e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "76e2cdf903714d4091be46587a92243d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "382de7a6445e4fac80cff3611eb3ce68", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f2053bdf2a794c6f8e2f13870bb39481", + "Value": { + "$ID": "602854fc3f4046e9b30298ad1e210f8c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "65324de5a46046048c4dbb86ce0edfd2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c85d44b4223746c58da7acdcdde7c1c5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "13b1e09f6e924cc4b68c0b2a333ba3e6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "079e690b9a5540199ed9457cfda85700", + "Value": { + "$ID": "becbad6ecee4417b958493b5c79f81fc", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b5ba892d6f724f1d84ddc7df3569569d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7e14afd20e9a434da505f43544390480", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0dcb2802c3b647d1a24de2b75d0be2c9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "45d0d05e8bfa44fb9f9ca1b15601f4f2", + "Value": { + "$ID": "363e08dbded84cec8593fe9eb415ff82", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "61db5b151cf04d27bee849521656bc24", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a6ce288bfa6040fb882d7cfaf3fbe247", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "3467f08458064a128757a1c7108ddf0b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "83f940d2d8e241ca814f598021dba1a9", + "Value": { + "$ID": "acccdc025acb4c18abc36f57f3829897", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "63de929afcaf4ffdb2c20eeb19a0b907", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "f02241b169a844d387a81ab9c63e08d0", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "e3fb76efa0c1450c9c41b32315631276", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "2007a5ee1d1243f68544a315f5f2c3d4", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "e6046a4f671442d5a6f624d4b13fec78", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8d576228a98a4f329c98fa31a0a1815a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a94caf85279a41039ac8704c56ff144c", + "Value": { + "$ID": "abba43c7e0654338be83eec49be091df", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6520509ae5614223a0b8feae57208154", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "9e1bb45e44f2461685181ec042625610", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "db31be2308d54bfebc59a29b2b3ed274", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "71d79523dc5f4fe1b41b854a3d48191e", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "86524910ce114f51974d6a0282d2b154", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "3222b43ef9e94d46a22af78a7f095471", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f7f250cf1d13489a81e481cea8cb883b", + "Value": { + "$ID": "f9e9a352b96c4750953d562289b40162", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2d68dd6a251947a4900607a196d71546", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "caa8e784dab04e1db9f2e2854aee0e65", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "8d2ef08251a9436794e176433c48e493", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "4a1769e7e7214a3b939c81d985e2c500", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "617786fc63b7407cbfdb58763c59f035", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "36ca0fbf5eb349ceaf57c2af8b3a3e88", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "27d0cddf48cb423188d30c919e30e4fc", + "Value": { + "$ID": "34011eb4563f490282bc94c2dcb15345", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "cce6fc9166d148adb8c9043a17aec702", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "1c9ade5b375b44328b8b3ef8d096e60e", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "5ab0e827ef0349b4b2394f3c17fc8f83", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "d07cc2829cad463e806b704b1450280e", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "1e8cf5197fab423f9b8b32ff4e3f8cd5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "00959aeb8d2d4e81a9021db667b2d96c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b86b18c5971947d78d28751c71e3859f", + "Value": { + "$ID": "eb1e8074a3d24e6dbda0c60709805724", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0e9f2f9752094239bc2ed15f8f232b40", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "c1f84ec0ff014de58c55566b529f2a6d", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "b3d72233516648c09218c60d0e654018", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "7c820bfa023a4a27880254fcde0a8cbb", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "66908f0edb2b4b6c9d768de04f866d8e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "738181a29a084e5199e60a4908c0a2d6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "bbb8f2f283f3498d817401dafd1f7d0d", + "Value": { + "$ID": "66d7874bdd1f4cb6af4124eadc008c83", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8475deca8c7548c39a1c426bd2b943f8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "00d3b9ec0bea4908a88b2f1b1eca71fc", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "bcbf270b67dc4a3483517a448f7c4ee7", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "e4fd420d59d84cc49b18aa9c721dd8cb", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "71f1cbf825c74604a2b978fefd922903", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "d1986b3305b14cb1830e64290f4e4495" + }, + "type": { + "$ID": "b42caa640fdc41709081ff852d6aea61", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/modules/gallery", + "ObjectType": { + "$ID": "d1986b3305b14cb1830e64290f4e4495", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "31b0a9721089471abe1c08cb8cdb5ffe", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filters placeholder", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "filtersPlaceholder", + "ValueType": { + "$ID": "d6c17d7292f34211b20684b4a38725da", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "7b02df9d9e5c42f4a658ce6044dc12b8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Data source", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "datasource", + "ValueType": { + "$ID": "bb30b0cf807d447c8b412fe11f812062", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "58f38ab267564da9b78fe179190a392a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selection", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "itemSelection", + "ValueType": { + "$ID": "492aa01efc0f4e7e987134391a6c2a2a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1, + "None", + "Single", + "Multi" + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Selection" + } + }, + { + "$ID": "6509b8c61dbd4485897d8b0929aa3d15", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Item click toggles selection", + "Category": "General::General", + "Description": "Defines item selection behavior.", + "IsDefault": false, + "PropertyKey": "itemSelectionMode", + "ValueType": { + "$ID": "405c5594324241198c7d8ec673ea2626", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "clear", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "e992a4d2c2934ec5bfcad4503a5ed4d8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Yes", + "_Key": "toggle" + }, + { + "$ID": "2b6ce9fc257949b981f34b6bafdcd348", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "No", + "_Key": "clear" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "f929496fda154e9ea5a0bee0c8055fe9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Keep selection", + "Category": "General::General", + "Description": "If enabled, selected items will stay selected unless cleared by the user or a Nanoflow.", + "IsDefault": false, + "PropertyKey": "keepSelection", + "ValueType": { + "$ID": "cfc0f50efae9455cbbd1f6d06c97cb19", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "6c97ba7e6cd44dcfa7d7ec4fe98d5918", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Content placeholder", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "content", + "ValueType": { + "$ID": "5cadb97bf49546a5afaee593b6d2f398", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "d5311097fe25421ea154aa10b878a98f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show refresh indicator", + "Category": "General::General", + "Description": "Show a refresh indicator when the data is being loaded.", + "IsDefault": false, + "PropertyKey": "refreshIndicator", + "ValueType": { + "$ID": "31d9a35c3e974c0ba74882887b4d0f45", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "8f340a34ad2a4324a78d68aeb7c9c882", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Desktop columns", + "Category": "General::Columns", + "Description": "", + "IsDefault": false, + "PropertyKey": "desktopItems", + "ValueType": { + "$ID": "cf9eb5e4f3b14cfe8c0e37028c942ac7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "1", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "04f980cab72c4affb41e02d7e4af34d7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tablet columns", + "Category": "General::Columns", + "Description": "", + "IsDefault": false, + "PropertyKey": "tabletItems", + "ValueType": { + "$ID": "660d46ce13174f57b1c66ca48734b0ed", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "1", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "0b0a9ffd0f1a4ed5a241f25bcf2bdbda", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Phone columns", + "Category": "General::Columns", + "Description": "", + "IsDefault": false, + "PropertyKey": "phoneItems", + "ValueType": { + "$ID": "3ddf7e99ae424a058abb511b1a5ca407", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "1", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "f2473f5cde00484ea9e49c1aef65ad94", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Page size", + "Category": "General::Pagination", + "Description": "", + "IsDefault": false, + "PropertyKey": "pageSize", + "ValueType": { + "$ID": "14208c2884f74d6e80f38452433fe656", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "20", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "fc6e9c443b194c2aafa7ea730bc8981b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Pagination", + "Category": "General::Pagination", + "Description": "", + "IsDefault": false, + "PropertyKey": "pagination", + "ValueType": { + "$ID": "1982af8c020d4130b51381a095cf70bc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "buttons", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "458dedc0d3884eccb7800c4dc9701c92", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Paging buttons", + "_Key": "buttons" + }, + { + "$ID": "08337e9751b040b480bc1e587d393ac7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Virtual scrolling", + "_Key": "virtualScrolling" + }, + { + "$ID": "34fbe118e55248e89c5d1a5e9077d83c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Load more", + "_Key": "loadMore" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "9d8ba4410ec741428ad3b687d85ff01f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show total count", + "Category": "General::Pagination", + "Description": "", + "IsDefault": false, + "PropertyKey": "showTotalCount", + "ValueType": { + "$ID": "99bd880b563146ddbd134b24e349184b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "a375ce9727114e87a9d6f9f99f2ab273", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show paging buttons", + "Category": "General::Pagination", + "Description": "", + "IsDefault": false, + "PropertyKey": "showPagingButtons", + "ValueType": { + "$ID": "88f8002d05e447c1a05f9cb26d62452f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "always", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "661dd3106bdf4a78bc4fadba4cac7453", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Always", + "_Key": "always" + }, + { + "$ID": "baf7389746b1434e8ab5e6dd5b28afb2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto", + "_Key": "auto" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "4d33e089d6674b03825cd502cc3cfbc0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Position of pagination", + "Category": "General::Pagination", + "Description": "", + "IsDefault": false, + "PropertyKey": "pagingPosition", + "ValueType": { + "$ID": "f0d7674deea345deba27b38afb8623b6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "bottom", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "ad7c9f810bbf46f5bb06eeb11a0fc298", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Below grid", + "_Key": "bottom" + }, + { + "$ID": "958b30f7a7654da1b8e960c9476db678", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Above grid", + "_Key": "top" + }, + { + "$ID": "af405e28f14641af8647b9763d7ad07a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Both", + "_Key": "both" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "32a8013811444fc1bbab8658a9320748", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Load more caption", + "Category": "General::Pagination", + "Description": "", + "IsDefault": false, + "PropertyKey": "loadMoreButtonCaption", + "ValueType": { + "$ID": "a41df587f3ee4577984a619e2492155b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2, + { + "$ID": "e45e3f2f2bed456eb25d371703ede949", + "$Type": "CustomWidgets$WidgetTranslation", + "LanguageCode": "en_US", + "Text": "Load More" + } + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "b53bbbd25d9a453f9dc8e243d6cd91c8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Empty message", + "Category": "General::Items", + "Description": "", + "IsDefault": false, + "PropertyKey": "showEmptyPlaceholder", + "ValueType": { + "$ID": "bdc82f03aef74c3dbba1bbc3466661ef", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "none", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "9291781d01a941ea8aee79a2551026b3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "None", + "_Key": "none" + }, + { + "$ID": "64517ae1b50245edb187f6ab773bbff0", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Custom", + "_Key": "custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "ee55b425bb8042dc9d2c8212b7b4cd70", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Empty placeholder", + "Category": "General::Items", + "Description": "", + "IsDefault": false, + "PropertyKey": "emptyPlaceholder", + "ValueType": { + "$ID": "e387c1970f184dd6881a3f56cbebe141", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "ecf8d48a9990406cbc6d46c96972eeb2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Dynamic item class", + "Category": "General::Items", + "Description": "", + "IsDefault": false, + "PropertyKey": "itemClass", + "ValueType": { + "$ID": "37e4f35bbd144641a2c85547d55ec82d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "df6b51260a8e4cdf9698544838b9a3f3", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "7b4c9566e96b4b028786d3eb9e481c37", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click trigger", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClickTrigger", + "ValueType": { + "$ID": "0dd3285dccee4455b7d4529c8205b09d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "single", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "7331a4a7fed04c2a93bb1ffbabb95ce5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Single click", + "_Key": "single" + }, + { + "$ID": "116a4c55794b4bfc971543762112ae6b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Double click", + "_Key": "double" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "41affea39a70496eacc65f9020a7ca51", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click action", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClick", + "ValueType": { + "$ID": "8bca76ec55ef446bb8920f78b45fb81f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "8900de019370404c8ad1c2d7d2c91083", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On selection change", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onSelectionChange", + "ValueType": { + "$ID": "99e8ceb69ae7404093f14ee2178d30d8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "012cb6be356041ed8b4832e7b5285435", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Store configuration in", + "Category": "Personalization::Configuration", + "Description": "When Browser local storage is selected, the configuration is scoped to a browser profile. This configuration is not tied to a Mendix user.", + "IsDefault": false, + "PropertyKey": "stateStorageType", + "ValueType": { + "$ID": "dbcc5f5ce880497ea86cd6124f790b6c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "attribute", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "550fc913c0ab43ccb327beb7ea8443da", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Attribute", + "_Key": "attribute" + }, + { + "$ID": "f270cd1c58284024a3b0981e665c61f0", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Browser local storage", + "_Key": "localStorage" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "a9bba43d45524fdebc5646cd21825fa5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "Personalization::Configuration", + "Description": "Attribute containing the personalized configuration of the capabilities. This configuration is automatically stored and loaded. The attribute requires Unlimited String.", + "IsDefault": false, + "PropertyKey": "stateStorageAttr", + "ValueType": { + "$ID": "76e2cdf903714d4091be46587a92243d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1, + "String" + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "onConfigurationChange", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "f2053bdf2a794c6f8e2f13870bb39481", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "Personalization::Configuration", + "Description": "", + "IsDefault": false, + "PropertyKey": "onConfigurationChange", + "ValueType": { + "$ID": "c85d44b4223746c58da7acdcdde7c1c5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "079e690b9a5540199ed9457cfda85700", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Store filters", + "Category": "Personalization::Configuration", + "Description": "", + "IsDefault": false, + "PropertyKey": "storeFilters", + "ValueType": { + "$ID": "7e14afd20e9a434da505f43544390480", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "45d0d05e8bfa44fb9f9ca1b15601f4f2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Store sort", + "Category": "Personalization::Configuration", + "Description": "", + "IsDefault": false, + "PropertyKey": "storeSort", + "ValueType": { + "$ID": "a6ce288bfa6040fb882d7cfaf3fbe247", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "83f940d2d8e241ca814f598021dba1a9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Filter section", + "Category": "Accessibility::Aria labels", + "Description": "Assistive technology will read this upon reaching a filtering or sorting section.", + "IsDefault": false, + "PropertyKey": "filterSectionTitle", + "ValueType": { + "$ID": "e6046a4f671442d5a6f624d4b13fec78", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "a94caf85279a41039ac8704c56ff144c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Empty message", + "Category": "Accessibility::Aria labels", + "Description": "Assistive technology will read this upon reaching an empty message section.", + "IsDefault": false, + "PropertyKey": "emptyMessageTitle", + "ValueType": { + "$ID": "86524910ce114f51974d6a0282d2b154", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "f7f250cf1d13489a81e481cea8cb883b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Content description", + "Category": "Accessibility::Aria labels", + "Description": "Assistive technology will read this upon reaching gallery.", + "IsDefault": false, + "PropertyKey": "ariaLabelListBox", + "ValueType": { + "$ID": "617786fc63b7407cbfdb58763c59f035", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "27d0cddf48cb423188d30c919e30e4fc", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Item description", + "Category": "Accessibility::Aria labels", + "Description": "Assistive technology will read this upon reaching each gallery item.", + "IsDefault": false, + "PropertyKey": "ariaLabelItem", + "ValueType": { + "$ID": "1e8cf5197fab423f9b8b32ff4e3f8cd5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "b86b18c5971947d78d28751c71e3859f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Item count singular", + "Category": "Accessibility::Aria labels", + "Description": "Must include '%d' to denote number position ('%d item selected')", + "IsDefault": false, + "PropertyKey": "selectedCountTemplateSingular", + "ValueType": { + "$ID": "66908f0edb2b4b6c9d768de04f866d8e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "bbb8f2f283f3498d817401dafd1f7d0d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Item count plural", + "Category": "Accessibility::Aria labels", + "Description": "Must include '%d' to denote number position ('%d items selected')", + "IsDefault": false, + "PropertyKey": "selectedCountTemplatePlural", + "ValueType": { + "$ID": "71f1cbf825c74604a2b978fefd922903", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Data Containers", + "StudioProCategory": "Data containers", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.gallery.Gallery", + "WidgetName": "Gallery", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/htmlelement.json b/modelsdk/widgets/templates/mendix-11.6/htmlelement.json new file mode 100644 index 00000000..c83a0a0c --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/htmlelement.json @@ -0,0 +1,2723 @@ +{ + "widgetId": "com.mendix.widget.web.htmlelement.HTMLElement", + "name": "HTML Element", + "version": "11.6.4", + "extractedFrom": "c8276e45-b488-4a96-bf97-6779dabb9790", + "type": { + "$ID": "140e3e654c8a4174ad1013a033a87fff", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/htmlelement", + "ObjectType": { + "$ID": "9eff0a9186c84b9f806909f4ce05074e", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "62ebe9c3314e49da894ffe8571bf648c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tag name", + "Category": "General::HTML element", + "Description": "", + "IsDefault": false, + "PropertyKey": "tagName", + "ValueType": { + "$ID": "de627189f12d44ff8544d485beca832e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "div", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "745a8eb8adae4a91aba46a939a8f559e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "div", + "Caption": "div" + }, + { + "$ID": "6a82fb5ec12543f69af6e43e24a79a4a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "span", + "Caption": "span" + }, + { + "$ID": "6c104f347366481f87c117808192d347", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "p", + "Caption": "p" + }, + { + "$ID": "0a3aba0c732e41aba6a89e19d91a22a6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "ul", + "Caption": "ul" + }, + { + "$ID": "2eb03d4ae5f24749a2b75c33191b3ac1", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "ol", + "Caption": "ol" + }, + { + "$ID": "9ee5536b5ac24c629de1c14718cab5b1", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "li", + "Caption": "li" + }, + { + "$ID": "98607bdccf6c4da281c8d890bb0281d0", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "a", + "Caption": "a" + }, + { + "$ID": "65bbe4f3e79f4461807d24aeb3a71134", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "img", + "Caption": "img" + }, + { + "$ID": "8a2d7f72b6bf4170908595a7b5a8bfe1", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "h1", + "Caption": "h1" + }, + { + "$ID": "f1c2ea0b4cc741dcb0f7719c8d298c0a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "h2", + "Caption": "h2" + }, + { + "$ID": "a0062f79ec54486cb4c4fc720f69e3e7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "h3", + "Caption": "h3" + }, + { + "$ID": "4a57fd8230114bbda1ed955e9fa6e459", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "h4", + "Caption": "h4" + }, + { + "$ID": "1c42867c2f6c40ee8f4ea060c4909cf2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "h5", + "Caption": "h5" + }, + { + "$ID": "c30d7c67dc3145448cec6ce26746a4ee", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "h6", + "Caption": "h6" + }, + { + "$ID": "9861366505f942cdbc0838b4e68b286e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "__customTag__", + "Caption": "Use custom name" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "a667e0a50f7c45d3b24fb63a6d7817e0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom tag", + "Category": "General::HTML element", + "Description": "", + "IsDefault": false, + "PropertyKey": "tagNameCustom", + "ValueType": { + "$ID": "0111ed2547cd419ba03f8db23e4be3e8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "div", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + }, + { + "$ID": "a710678d5c34478cba15ec23732c28b9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Repeat element", + "Category": "General::HTML element", + "Description": "Repeat element for each item in data source.", + "IsDefault": false, + "PropertyKey": "tagUseRepeat", + "ValueType": { + "$ID": "d73a18adc15649f3beb06117a63acbe2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "ad3d8d8e1bdf4ebe8ca7c986e8a14c0b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Data source", + "Category": "General::HTML element", + "Description": "", + "IsDefault": false, + "PropertyKey": "tagContentRepeatDataSource", + "ValueType": { + "$ID": "fd92cd4f02614494b02894f94b443268", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "f708f35ab1a4411c9223d3ceef3729d7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Content", + "Category": "General::HTML element", + "Description": "", + "IsDefault": false, + "PropertyKey": "tagContentMode", + "ValueType": { + "$ID": "76a063ead93a4237a4c0dddc6f88dc81", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "container", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "77102354b9e940d9b8ba1ddf6add5f10", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "container", + "Caption": "Container for widgets" + }, + { + "$ID": "2c576aa025984036a24636bcd13371eb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "innerHTML", + "Caption": "HTML" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "9fc1be7221e74c179ef5682a4b647dc9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "HTML", + "Category": "General::HTML element", + "Description": "", + "IsDefault": false, + "PropertyKey": "tagContentHTML", + "ValueType": { + "$ID": "edca5b43e8644cd6a7babe04e334e543", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": true, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "298b6067ae484064ad7c2dde6c327b85", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Content", + "Category": "General::HTML element", + "Description": "", + "IsDefault": false, + "PropertyKey": "tagContentContainer", + "ValueType": { + "$ID": "5de72ea0bb4a4366b2a27f221f012582", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "da6bbe716fc44cbdb86bc362102f5817", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "HTML", + "Category": "General::HTML element", + "Description": "", + "IsDefault": false, + "PropertyKey": "tagContentRepeatHTML", + "ValueType": { + "$ID": "c6876ed9e0984185807545c007358207", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "tagContentRepeatDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": true, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "02c28e671b5544399939118564eadb48", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Content", + "Category": "General::HTML element", + "Description": "", + "IsDefault": false, + "PropertyKey": "tagContentRepeatContainer", + "ValueType": { + "$ID": "7bd9f6abb6a04e0ebce046651c3876f6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "tagContentRepeatDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "710f85e985524f17a0d53a1104518b2d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attributes", + "Category": "General::HTML attributes", + "Description": "The HTML attributes that are added to the HTML element. For example: ‘title‘, ‘href‘. If ‘class’ or ‘style’ is added as attribute this is merged with the widget class/style property. For events (e.g. onClick) use the Events section.", + "IsDefault": false, + "PropertyKey": "attributes", + "ValueType": { + "$ID": "f81a352a90ce40ee967742f44ec8d5c2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "0c7166b9731349b59dc7894874711355", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "b432009582994e80a50f25c5d0e4066e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Name", + "Category": "Attributes", + "Description": "", + "IsDefault": false, + "PropertyKey": "attributeName", + "ValueType": { + "$ID": "cb1ac89cf4de43239d94474c546ad9a8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + }, + { + "$ID": "b66420acb7b74eaaa976304b293da3ae", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value based on", + "Category": "Attributes", + "Description": "", + "IsDefault": false, + "PropertyKey": "attributeValueType", + "ValueType": { + "$ID": "f451034c5ccd4efe8a93767e474fdcce", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "expression", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "b634f957a7ae4cd3a5a548ed366008aa", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + }, + { + "$ID": "a8fef238c86a4e2ea124291659559360", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "template", + "Caption": "Text template" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "fb3b944f7b9649c692aee42a61f5037e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value", + "Category": "Attributes", + "Description": "", + "IsDefault": false, + "PropertyKey": "attributeValueTemplate", + "ValueType": { + "$ID": "39489dfce04b4ed9a23c9ba0756a72c8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "0351558d3f6a4c8f91ed16199b3f9ad1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value", + "Category": "Attributes", + "Description": "", + "IsDefault": false, + "PropertyKey": "attributeValueExpression", + "ValueType": { + "$ID": "df254738e41a4728b96b9cecfcad7c60", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "ad656bfc1d384586a6b1fcff4e05aea6", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "ef3bc8b02e7d4e208a0cad595242de9d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value", + "Category": "Attributes", + "Description": "", + "IsDefault": false, + "PropertyKey": "attributeValueTemplateRepeat", + "ValueType": { + "$ID": "fdc8d66fd5b5411b80f31eda2a382bab", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../tagContentRepeatDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "65d8203f50704084baf7c66ac005b9ef", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value", + "Category": "Attributes", + "Description": "", + "IsDefault": false, + "PropertyKey": "attributeValueExpressionRepeat", + "ValueType": { + "$ID": "52cfc59726954074ada07704ca64e057", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../tagContentRepeatDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "e15a32ae19264f5d9ce896a2af18b6e9", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "1411c33495a74f288e99278409d4199c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Events", + "Category": "Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "events", + "ValueType": { + "$ID": "7b60fcc7cf0c447aa73c3bd0ff3db62c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "9e8c3c0815534b178710603b289c578a", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "473b9e0a22704cf0940f8bbb8713bc4a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Name", + "Category": "Event", + "Description": "", + "IsDefault": false, + "PropertyKey": "eventName", + "ValueType": { + "$ID": "101b15e134d34294810eb7dccdc2ed94", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "onClick", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "16aa2ce3382c4c72bafa4302450b2269", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onAbort", + "Caption": "onAbort" + }, + { + "$ID": "ecdca3ae296d47299ac667df6d525c3a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onAbortCapture", + "Caption": "onAbortCapture" + }, + { + "$ID": "317486f339084853aace05580e9d1957", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onAnimationEnd", + "Caption": "onAnimationEnd" + }, + { + "$ID": "2ce5e35673a0468bab8667fca06bd9f2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onAnimationEndCapture", + "Caption": "onAnimationEndCapture" + }, + { + "$ID": "98696cdf2ef54ef3b173f64648f18d68", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onAnimationIteration", + "Caption": "onAnimationIteration" + }, + { + "$ID": "f9351199a2a74af6b0b37bf999814694", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onAnimationIterationCapture", + "Caption": "onAnimationIterationCapture" + }, + { + "$ID": "6ea1b6f992af49d59017b49d013efcdd", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onAnimationStart", + "Caption": "onAnimationStart" + }, + { + "$ID": "b1d98a45724a4dd39e7f3c844cffbd6b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onAnimationStartCapture", + "Caption": "onAnimationStartCapture" + }, + { + "$ID": "bd35d9e2056248d395e5f4d8ec64ec9f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onAuxClick", + "Caption": "onAuxClick" + }, + { + "$ID": "5f18c6a5310042c1b5eaabe93e764d74", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onAuxClickCapture", + "Caption": "onAuxClickCapture" + }, + { + "$ID": "5f376a9ea4ed4ff38959fe7c65cafc1f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onBeforeInput", + "Caption": "onBeforeInput" + }, + { + "$ID": "732bb09f939048d2af5ae4c3769db891", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onBeforeInputCapture", + "Caption": "onBeforeInputCapture" + }, + { + "$ID": "221f84e9786547149b88b0a6f1d9e7fd", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onBlur", + "Caption": "onBlur" + }, + { + "$ID": "891ee37aaad24779b9695b368ea28733", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onBlurCapture", + "Caption": "onBlurCapture" + }, + { + "$ID": "0a463e859e374f4ca240420ff87c35d5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCanPlay", + "Caption": "onCanPlay" + }, + { + "$ID": "628cf4b384024e2caee22df103614115", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCanPlayCapture", + "Caption": "onCanPlayCapture" + }, + { + "$ID": "61e4d294850f4f659082578ee7457853", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCanPlayThrough", + "Caption": "onCanPlayThrough" + }, + { + "$ID": "9cb0b8c82b464452980df41e9e2e304c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCanPlayThroughCapture", + "Caption": "onCanPlayThroughCapture" + }, + { + "$ID": "ebbae824bab9412a83d4acc376f6fa89", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onChange", + "Caption": "onChange" + }, + { + "$ID": "8edb852d3a0840a3a448695efc4f9285", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onChangeCapture", + "Caption": "onChangeCapture" + }, + { + "$ID": "79b50ff304b34fae9f31a234e2cf8c36", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onClick", + "Caption": "onClick" + }, + { + "$ID": "113b6cb010ea442b9e56e143b655be60", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onClickCapture", + "Caption": "onClickCapture" + }, + { + "$ID": "fe2d3219b5744f858cc7cb9dba51861f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCompositionEnd", + "Caption": "onCompositionEnd" + }, + { + "$ID": "2eb79f7ccbb74cddaf2640771fe9ed55", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCompositionEndCapture", + "Caption": "onCompositionEndCapture" + }, + { + "$ID": "6883a83259c8409285796f08133b452b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCompositionStart", + "Caption": "onCompositionStart" + }, + { + "$ID": "88352a563bf94878974fb9707c85654d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCompositionStartCapture", + "Caption": "onCompositionStartCapture" + }, + { + "$ID": "61455408f63041e1b334f2f923b555cf", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCompositionUpdate", + "Caption": "onCompositionUpdate" + }, + { + "$ID": "54a5b438d25b49dc823470f1629858d5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCompositionUpdateCapture", + "Caption": "onCompositionUpdateCapture" + }, + { + "$ID": "a702d6d3a14c450d8ec4954015d1073a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onContextMenu", + "Caption": "onContextMenu" + }, + { + "$ID": "826d110cacab4490a6b6dbd4f8a98c52", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onContextMenuCapture", + "Caption": "onContextMenuCapture" + }, + { + "$ID": "59d748b7d3fd40dbace0f4aa930cf2f2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCopy", + "Caption": "onCopy" + }, + { + "$ID": "b0e4787e401347478000baefb93f12bb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCopyCapture", + "Caption": "onCopyCapture" + }, + { + "$ID": "c147b7e571b14b41a18626581102f8c2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCut", + "Caption": "onCut" + }, + { + "$ID": "0be4c8a071114dbe95aefcc9395a63e8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onCutCapture", + "Caption": "onCutCapture" + }, + { + "$ID": "0b9c2a9c3cd64f089d4805677113aa8f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDoubleClick", + "Caption": "onDoubleClick" + }, + { + "$ID": "aea01328e7434cea9e60aef609f4cc78", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDoubleClickCapture", + "Caption": "onDoubleClickCapture" + }, + { + "$ID": "7264620d539049c09f8c4c38df67c537", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDrag", + "Caption": "onDrag" + }, + { + "$ID": "54bb174d971241e488b64b66a74a0e15", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragCapture", + "Caption": "onDragCapture" + }, + { + "$ID": "0792197528b34436bebb6c3cc5075d63", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragEnd", + "Caption": "onDragEnd" + }, + { + "$ID": "32f9c923e16b4c4aa961ef6c52bc3e8b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragEndCapture", + "Caption": "onDragEndCapture" + }, + { + "$ID": "a30e5786d581402899c60b84fa60ead1", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragEnter", + "Caption": "onDragEnter" + }, + { + "$ID": "b7bb5db1459b450ea0d23d241ac64a64", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragEnterCapture", + "Caption": "onDragEnterCapture" + }, + { + "$ID": "95080fd7e9a94084a747470f57c3b633", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragExit", + "Caption": "onDragExit" + }, + { + "$ID": "2f94c4e005f141da891f89c7f0309b31", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragExitCapture", + "Caption": "onDragExitCapture" + }, + { + "$ID": "137d0af02ab244239418aff5569cf14e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragLeave", + "Caption": "onDragLeave" + }, + { + "$ID": "2949e8b28960485a94cc671c60668165", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragLeaveCapture", + "Caption": "onDragLeaveCapture" + }, + { + "$ID": "81d7430a7e6544b9a0f7515f187e07a5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragOver", + "Caption": "onDragOver" + }, + { + "$ID": "70203334d4ef4894a5daa24be4b4d7a6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragOverCapture", + "Caption": "onDragOverCapture" + }, + { + "$ID": "315e6ff4d37941d0b73243f40b4291d9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragStart", + "Caption": "onDragStart" + }, + { + "$ID": "3e0afd28321447ccb7651b3bfe2dd90f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDragStartCapture", + "Caption": "onDragStartCapture" + }, + { + "$ID": "1f794e0d88c9486592391a390d9d5ba3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDrop", + "Caption": "onDrop" + }, + { + "$ID": "9f129473df884d13b143e19d377fc985", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDropCapture", + "Caption": "onDropCapture" + }, + { + "$ID": "299fa7ed82004948a4548e5b7480f813", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDurationChange", + "Caption": "onDurationChange" + }, + { + "$ID": "bf6d7a97192c45b5883c80750b841332", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onDurationChangeCapture", + "Caption": "onDurationChangeCapture" + }, + { + "$ID": "1669174bb20d4ab592f65f9e0ba267ee", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onEmptied", + "Caption": "onEmptied" + }, + { + "$ID": "465f073847544a01b0283f45be19beed", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onEmptiedCapture", + "Caption": "onEmptiedCapture" + }, + { + "$ID": "27c171679f9145e4b5d012221c22345a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onEncrypted", + "Caption": "onEncrypted" + }, + { + "$ID": "35e564421be04f268e74c198b15f179e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onEncryptedCapture", + "Caption": "onEncryptedCapture" + }, + { + "$ID": "4f265e8715da45bf9debd03618d35017", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onEnded", + "Caption": "onEnded" + }, + { + "$ID": "4a3d85a91a404068b9fb53258ae4fe71", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onEndedCapture", + "Caption": "onEndedCapture" + }, + { + "$ID": "267bbef13c184e4a98720c690bcf1eb3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onError", + "Caption": "onError" + }, + { + "$ID": "70ce3c257ed34282a624b189cf4eb80d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onErrorCapture", + "Caption": "onErrorCapture" + }, + { + "$ID": "60ef040d550244538db14d3a23f92660", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onFocus", + "Caption": "onFocus" + }, + { + "$ID": "c15e5591312d4027b25909dd5474328e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onFocusCapture", + "Caption": "onFocusCapture" + }, + { + "$ID": "7dd99a4cd72e4e7f8412cf53c13c70d8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onGotPointerCapture", + "Caption": "onGotPointerCapture" + }, + { + "$ID": "b1e77ad1785d40ad960681c166a03d30", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onGotPointerCaptureCapture", + "Caption": "onGotPointerCaptureCapture" + }, + { + "$ID": "bfca6a0b87f4418cb0234f95b5fb8604", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onInput", + "Caption": "onInput" + }, + { + "$ID": "b7127ba611cf4ff7b35971fb2235f665", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onInputCapture", + "Caption": "onInputCapture" + }, + { + "$ID": "a4beb7df04594576a4d30c7075f6638d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onInvalid", + "Caption": "onInvalid" + }, + { + "$ID": "3403695cb9644d54bbd0b0491cf7e3e0", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onInvalidCapture", + "Caption": "onInvalidCapture" + }, + { + "$ID": "5d9b5dc178ef468a913f0f363bfee1c8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onKeyDown", + "Caption": "onKeyDown" + }, + { + "$ID": "db0817375da54913857767dbd64adacf", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onKeyDownCapture", + "Caption": "onKeyDownCapture" + }, + { + "$ID": "f1a43d405796498ab8bdbcabfad61760", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onKeyPress", + "Caption": "onKeyPress" + }, + { + "$ID": "04968500807b4f27a3096cc616e72177", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onKeyPressCapture", + "Caption": "onKeyPressCapture" + }, + { + "$ID": "9cc8322c5c494cda902ec2b2900c9bae", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onKeyUp", + "Caption": "onKeyUp" + }, + { + "$ID": "ea6f4de9b45b4561b80ab81244c150c8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onKeyUpCapture", + "Caption": "onKeyUpCapture" + }, + { + "$ID": "af8e3ee33f534c2180267038088c8e11", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLeave", + "Caption": "onLeave" + }, + { + "$ID": "5dfc1cb4f4f84e1a99d832ee25c30aff", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLoad", + "Caption": "onLoad" + }, + { + "$ID": "f6fddc6cbaa149ec8551e72ad29852a5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLoadCapture", + "Caption": "onLoadCapture" + }, + { + "$ID": "10673995e81b4bdab7f61c17df13610d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLoadedData", + "Caption": "onLoadedData" + }, + { + "$ID": "69221601be7a46bdad0da216db9a7bac", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLoadedDataCapture", + "Caption": "onLoadedDataCapture" + }, + { + "$ID": "ca18b76ebda74cd5b955546ab5a1fde9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLoadedMetadata", + "Caption": "onLoadedMetadata" + }, + { + "$ID": "2a83f883602a41f796d767d305bce9e5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLoadedMetadataCapture", + "Caption": "onLoadedMetadataCapture" + }, + { + "$ID": "ec896cd0866a476ea7ba7281e6145704", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLoadStart", + "Caption": "onLoadStart" + }, + { + "$ID": "64315215d96c4711a10aa5342bd38498", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLoadStartCapture", + "Caption": "onLoadStartCapture" + }, + { + "$ID": "189acd94c6d640d2af1f3faa07013f7a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLostPointerCapture", + "Caption": "onLostPointerCapture" + }, + { + "$ID": "71a550d1735f406e80008306e92919aa", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onLostPointerCaptureCapture", + "Caption": "onLostPointerCaptureCapture" + }, + { + "$ID": "df7cd19a02214675b044e8c2c14485fa", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseDown", + "Caption": "onMouseDown" + }, + { + "$ID": "cfaf681510c24c04949800960cabdca3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseDownCapture", + "Caption": "onMouseDownCapture" + }, + { + "$ID": "264387b021e34bca8c39416e49459d39", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseEnter", + "Caption": "onMouseEnter" + }, + { + "$ID": "dbb0a76cf4c246dfb6e6a55874310440", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseLeave", + "Caption": "onMouseLeave" + }, + { + "$ID": "b66be07c438c43b4826c6ca8d0fc3fdb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseMove", + "Caption": "onMouseMove" + }, + { + "$ID": "5e58d6f3c49c4f15875087c05aeb284e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseMoveCapture", + "Caption": "onMouseMoveCapture" + }, + { + "$ID": "3e161864949745f194d350c7b6042619", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseOut", + "Caption": "onMouseOut" + }, + { + "$ID": "3f658069a5834acbb920501a21e083df", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseOutCapture", + "Caption": "onMouseOutCapture" + }, + { + "$ID": "56cc1f89bc2948cdaa56de33c6ce9968", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseOver", + "Caption": "onMouseOver" + }, + { + "$ID": "46da9928e9a948c5aed9a1a05e2d56c7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseOverCapture", + "Caption": "onMouseOverCapture" + }, + { + "$ID": "629af293eefd489cb91ea96ecba7e17f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseUp", + "Caption": "onMouseUp" + }, + { + "$ID": "d6faa0aa62da4854b488d20a10bc081b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onMouseUpCapture", + "Caption": "onMouseUpCapture" + }, + { + "$ID": "16a3b71a9e15457b9b1b410aaba467e3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPaste", + "Caption": "onPaste" + }, + { + "$ID": "4d8c16281ae24d9d91bcdc76cfe5137e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPasteCapture", + "Caption": "onPasteCapture" + }, + { + "$ID": "9cc088419a0845bf856632cd76052969", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPause", + "Caption": "onPause" + }, + { + "$ID": "6e35a458ab684e718c5a5a7b74306262", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPauseCapture", + "Caption": "onPauseCapture" + }, + { + "$ID": "ee8173c186e2470a89364ff160a8963f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPlay", + "Caption": "onPlay" + }, + { + "$ID": "86a515580ce44cc090a818c83491039a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPlayCapture", + "Caption": "onPlayCapture" + }, + { + "$ID": "ba0b388d66f14da28f82532122c6d828", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPlaying", + "Caption": "onPlaying" + }, + { + "$ID": "e57935d0fbbe487bac35521cae33ed6c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPlayingCapture", + "Caption": "onPlayingCapture" + }, + { + "$ID": "132c7cb1b0a94e5f8edd346d38711c7c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerCancel", + "Caption": "onPointerCancel" + }, + { + "$ID": "47ac1d0c3449452ca1122c0e31462ad3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerCancelCapture", + "Caption": "onPointerCancelCapture" + }, + { + "$ID": "b362ac1eb7f648228dc22fd5fdc74d02", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerDown", + "Caption": "onPointerDown" + }, + { + "$ID": "e8c2f65237184744a1857461b1dc3e23", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerDownCapture", + "Caption": "onPointerDownCapture" + }, + { + "$ID": "8cf61ac7eaf74ba79c88b23c15b3f626", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerEnter", + "Caption": "onPointerEnter" + }, + { + "$ID": "2b19ad84edcb436dbb4d942163828ece", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerEnterCapture", + "Caption": "onPointerEnterCapture" + }, + { + "$ID": "776124d295ef481e91ddf40470fa60a6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerLeave", + "Caption": "onPointerLeave" + }, + { + "$ID": "36c52929c4624db4ab15db02705afb52", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerLeaveCapture", + "Caption": "onPointerLeaveCapture" + }, + { + "$ID": "c4ac07373d894c3dacdb7a82b21bee0b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerMove", + "Caption": "onPointerMove" + }, + { + "$ID": "46cbce29a6e941ceaa8309f81300e24f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerMoveCapture", + "Caption": "onPointerMoveCapture" + }, + { + "$ID": "744ba4b789894f2c968943a2a5fe564e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerOut", + "Caption": "onPointerOut" + }, + { + "$ID": "ef747e7138724f26bdce67bc24e726f7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerOutCapture", + "Caption": "onPointerOutCapture" + }, + { + "$ID": "da58706b36444c149579c78060db97ce", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerOver", + "Caption": "onPointerOver" + }, + { + "$ID": "b45c8fb42f684903a3e61a7cae9384a8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerOverCapture", + "Caption": "onPointerOverCapture" + }, + { + "$ID": "0366b3c944e54ca4a19bee892217af81", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerUp", + "Caption": "onPointerUp" + }, + { + "$ID": "d07c700466bd4156a54cf2229ce14450", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onPointerUpCapture", + "Caption": "onPointerUpCapture" + }, + { + "$ID": "d71b53e0f3b141a5886841ce206178a6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onProgress", + "Caption": "onProgress" + }, + { + "$ID": "420cc31c17eb41818435b6a7d3d3c637", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onProgressCapture", + "Caption": "onProgressCapture" + }, + { + "$ID": "e799b6218d844dbbb9da6d153d13257a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onRateChange", + "Caption": "onRateChange" + }, + { + "$ID": "df6f918ab6ea4c41942e0ce7b79e2629", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onRateChangeCapture", + "Caption": "onRateChangeCapture" + }, + { + "$ID": "538320405d9c40ce8b4bf5a7ee900833", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onReset", + "Caption": "onReset" + }, + { + "$ID": "e236d3bd8f684c108979f8add3ee800e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onResetCapture", + "Caption": "onResetCapture" + }, + { + "$ID": "e51537bfdbca4c16875071ec814a3859", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onScroll", + "Caption": "onScroll" + }, + { + "$ID": "87b93b666a4447889fb5ef64bfff137a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onScrollCapture", + "Caption": "onScrollCapture" + }, + { + "$ID": "ee4a824453fc46ec98f6248616eb96d4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onSeeked", + "Caption": "onSeeked" + }, + { + "$ID": "0997e3c3f99d4b8db2230c27e1e227ca", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onSeekedCapture", + "Caption": "onSeekedCapture" + }, + { + "$ID": "802856de81a4487e9a97c5dabd743dc9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onSeeking", + "Caption": "onSeeking" + }, + { + "$ID": "d4871d1219d74d91ba89dc046d2f21fb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onSeekingCapture", + "Caption": "onSeekingCapture" + }, + { + "$ID": "d001f13bc00342da879b42cb35f11899", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onSelect", + "Caption": "onSelect" + }, + { + "$ID": "31a3820422b349658879e65c8ed6d013", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onSelectCapture", + "Caption": "onSelectCapture" + }, + { + "$ID": "a4139c3f2c8341d3906e10831dbf7cf2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onStalled", + "Caption": "onStalled" + }, + { + "$ID": "60e41587ac1a4dbca98388de8a923185", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onStalledCapture", + "Caption": "onStalledCapture" + }, + { + "$ID": "9d71276e1b8843b59b4a06d3f5c56128", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onSubmit", + "Caption": "onSubmit" + }, + { + "$ID": "597680fc5f7a46ea90e6272c205fef45", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onSubmitCapture", + "Caption": "onSubmitCapture" + }, + { + "$ID": "574f15cf92df41cb9c92325c1b1914d5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onSuspend", + "Caption": "onSuspend" + }, + { + "$ID": "13049e7d4e9e47019907af2add329c4f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onSuspendCapture", + "Caption": "onSuspendCapture" + }, + { + "$ID": "46044b9025254e81b088027bb96d3f2c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTimeUpdate", + "Caption": "onTimeUpdate" + }, + { + "$ID": "236b2c595369468f9aad1e894aa070ac", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTimeUpdateCapture", + "Caption": "onTimeUpdateCapture" + }, + { + "$ID": "c3477e89c85f450abc94a653ed654ef3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTouchCancel", + "Caption": "onTouchCancel" + }, + { + "$ID": "76b8f7b37d4e48aab2c1a3f0bb4c6ec6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTouchCancelCapture", + "Caption": "onTouchCancelCapture" + }, + { + "$ID": "ed22a80a4b624fccb6102742802617ab", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTouchEnd", + "Caption": "onTouchEnd" + }, + { + "$ID": "d53f0d0863df4d748e199f12289ab63c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTouchEndCapture", + "Caption": "onTouchEndCapture" + }, + { + "$ID": "9f13011e85784500a6119a5e1c6d0472", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTouchMove", + "Caption": "onTouchMove" + }, + { + "$ID": "fab7eb0879f74523b3920c2776e76061", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTouchMoveCapture", + "Caption": "onTouchMoveCapture" + }, + { + "$ID": "7d4cda439aae45af9474bb93badba1d1", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTouchStart", + "Caption": "onTouchStart" + }, + { + "$ID": "41108db7d4bc4eabbde83fcba0f0dea8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTouchStartCapture", + "Caption": "onTouchStartCapture" + }, + { + "$ID": "fa2da4c477f84c2ca19134f6d3b063ac", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTransitionEnd", + "Caption": "onTransitionEnd" + }, + { + "$ID": "a9df598244374c34a78a0f589c61acb5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onTransitionEndCapture", + "Caption": "onTransitionEndCapture" + }, + { + "$ID": "9e87c9a928b64a5d8eae12699ef760de", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onVolumeChange", + "Caption": "onVolumeChange" + }, + { + "$ID": "48aa847dab104f998d75a3146e25a8f3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onVolumeChangeCapture", + "Caption": "onVolumeChangeCapture" + }, + { + "$ID": "6c2df58cf00e442984c0935a50ff0c3e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onWaiting", + "Caption": "onWaiting" + }, + { + "$ID": "68b287a81a8140638e3520bb969d715d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onWaitingCapture", + "Caption": "onWaitingCapture" + }, + { + "$ID": "b1fef6c3a7084a6295cbae8a74caacb3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onWheel", + "Caption": "onWheel" + }, + { + "$ID": "6bc3b79927d74c7f89d73ecdc36ad496", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onWheelCapture", + "Caption": "onWheelCapture" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "8b662f7fb59e42598326e9dda4f0137d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Action", + "Category": "Event", + "Description": "", + "IsDefault": false, + "PropertyKey": "eventAction", + "ValueType": { + "$ID": "cf76d2c5d86e4094ae949987acc62d7e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "21284a2b8136403e9df08c672652d3c9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Action", + "Category": "Event", + "Description": "", + "IsDefault": false, + "PropertyKey": "eventActionRepeat", + "ValueType": { + "$ID": "167dd30119f9415481e9c1ab7e634874", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "../tagContentRepeatDataSource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "e73856204a5041e199b3fff8959ae043", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Stop propagation", + "Category": "Advanced", + "Description": "", + "IsDefault": false, + "PropertyKey": "eventStopPropagation", + "ValueType": { + "$ID": "f09edd579b5d4c959c445bb2f528cb17", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "81d6ddcbbe3b46edb6df71e11048287b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Prevent default", + "Category": "Advanced", + "Description": "", + "IsDefault": false, + "PropertyKey": "eventPreventDefault", + "ValueType": { + "$ID": "4000c658ecda494d966da0301ceb2513", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "9c00d155cdfe41d1adb9803f939a26db", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Sanitization configuration", + "Category": "Advanced::HTML Sanitization", + "Description": "Configuration for HTML sanitization in JSON format. Leave blank for default.", + "IsDefault": false, + "PropertyKey": "sanitizationConfigFull", + "ValueType": { + "$ID": "7dbe171472494720a7d70bc012807799", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": true, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "", + "StudioProCategory": "", + "SupportedPlatform": "Web", + "WidgetDescription": "Displays custom HTML", + "WidgetId": "com.mendix.widget.web.htmlelement.HTMLElement", + "WidgetName": "HTML Element", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "7d959f4bcc834d7ab28516a917bf625f", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "6d59404bb0f249e9b91b81d01768ed0c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "62ebe9c3314e49da894ffe8571bf648c", + "Value": { + "$ID": "b374963170754774bcdaae37dbd272c8", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c3219a4e1b644441ae9190dc12880d85", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "div", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "de627189f12d44ff8544d485beca832e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f42d4913c72540f19e953b2be729c5d0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a667e0a50f7c45d3b24fb63a6d7817e0", + "Value": { + "$ID": "b20f28e2e8b247959c898ca1bf48b474", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3753d2aabc154ca6bcce2e92560369e7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "div", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0111ed2547cd419ba03f8db23e4be3e8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bcef8290b06e49e287888a9e6bec5b40", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a710678d5c34478cba15ec23732c28b9", + "Value": { + "$ID": "9ebec4cddc204eb19bcb9941fd73c3d5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "06d25ca9f0514774b850d85f15d3d14d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d73a18adc15649f3beb06117a63acbe2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1016612efe5148078f010f6a256e7dd1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ad3d8d8e1bdf4ebe8ca7c986e8a14c0b", + "Value": { + "$ID": "bac9eca8c2d7435ba462df6a89d06ab5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6973f2727d1b4bbb892a526eba1761c2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fd92cd4f02614494b02894f94b443268", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "39c75a7bb49745f8be1513b76aefe48f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f708f35ab1a4411c9223d3ceef3729d7", + "Value": { + "$ID": "59fb8e000e7b4500930aca763c383b95", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "57965a8dd3ca4003a4a041796ed505ea", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "container", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "76a063ead93a4237a4c0dddc6f88dc81", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "95d7f2fc488c424690ca581123ea95de", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9fc1be7221e74c179ef5682a4b647dc9", + "Value": { + "$ID": "1cc7a1526d694147b3bd3e7a7fe76278", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4582c3f52e6d43768450f66b06781da0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "edca5b43e8644cd6a7babe04e334e543", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "edeb7acc383843cea5b36461d278f0a7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "298b6067ae484064ad7c2dde6c327b85", + "Value": { + "$ID": "baa41685d45f4ef29cab412037b76d83", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "bb0ac4fd603a422a9f2d6773f336a94b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5de72ea0bb4a4366b2a27f221f012582", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6057d375583c4f4fae69d866d4b32de0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "da6bbe716fc44cbdb86bc362102f5817", + "Value": { + "$ID": "73141cc069504ddabcae9139549c9b3f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b2a868e06b704850b81b08f61833fe7a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c6876ed9e0984185807545c007358207", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f4916d98b2a541a39ddc51c6f7f1dc61", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "02c28e671b5544399939118564eadb48", + "Value": { + "$ID": "26c411b426274a0797a4aed94f54f70f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "70deb6593d5747908826239c99a0d108", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7bd9f6abb6a04e0ebce046651c3876f6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2d7d0d89debb410bb2d62b75df6a050a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "710f85e985524f17a0d53a1104518b2d", + "Value": { + "$ID": "c51bcbcf432c4dd2a52dfa1236ec113a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "386fd1b9905d4f2c84bcfbf30156d359", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f81a352a90ce40ee967742f44ec8d5c2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bd4c5d591faa4ff0869ffb2d98509990", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1411c33495a74f288e99278409d4199c", + "Value": { + "$ID": "5755a0e33b2f4589b63f56208af58d8e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2a0a3b3342ff4e358d4c2b12375dd2f1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7b60fcc7cf0c447aa73c3bd0ff3db62c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8e4fd75859614216a4215b67d61afe43", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9c00d155cdfe41d1adb9803f939a26db", + "Value": { + "$ID": "c1bce4c4188f4103afcc206376a416d5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9fcf09ac328b4f6eb469299c3f2a7035", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7dbe171472494720a7d70bc012807799", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "9eff0a9186c84b9f806909f4ce05074e" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/image.json b/modelsdk/widgets/templates/mendix-11.6/image.json new file mode 100644 index 00000000..1baf84ac --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/image.json @@ -0,0 +1,2116 @@ +{ + "extractedFrom": "65479f86-853e-443a-bd85-1930fba05994", + "name": "Image", + "object": { + "$ID": "95035404e13acc46970313f8627befff", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "da2883e713758c4dbdbcdc7180049786", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "330eee71236a1141b08f97a07bbf0aa7", + "Value": { + "$ID": "6aaccd368a686544b1b80736b8e122fd", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b82c73e94f09374fba3b8d98ee4b3ff3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "image", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "229fbed960b1b44abf1f5c60f841a6b1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "33e5f7b95fb0eb48b0eeb62011f519d6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "fbe1c66d9c58a841a0524bee96d1439c", + "Value": { + "$ID": "0485d489e372d244a663293779e38df5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "19136e426acb9949aab9a012c3163d5c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "Atlas_Core.Content.Mendix", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f3dc55b77449104fb21710616e882e9d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "23b08b07e542da48a8e0a281fe700b8b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e95a1541bb9b804791d2260857574667", + "Value": { + "$ID": "19e539b78575924fb78023d37974c7da", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "72498b7a862f2244b5924eccf365de72", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8390dbb64833bb4eabb8c47b305fdcf8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "af637698fbc1b5449c5de7215c641bb0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c32d2226de4b5a4cb5db08f7c8e7244b", + "Value": { + "$ID": "a012b2c558081e4b86f007de3bf0a889", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1843401381e3554e95e4bee298611915", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "202df245462c814c8372526b9f1fc855", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6f9a1cf9966da64bb50aa0c4a47ead29", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "68836e20ef627848b2d7bddafd91c8be", + "Value": { + "$ID": "a760e0aa64cd0745943cdfdc4b5ff9de", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "18704a8e789eab4bb3ca2ef01bd2884c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6f23b6f705cccc459e50276f2ccd914f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6c73a295f7aa4a4b9975b087e7784278", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "956c814e28c1604eabdb9d7548fc7bff", + "Value": { + "$ID": "e542ddc15d6c744a9022f4f1e88925e6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a2e3f2d884f147439904d3e0a879a9e4", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ae54b0987393784e8a09a6d3e61e8292", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "3ae21cbc5ceb7c4dba2181f462ccf690", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "bdf5007e0afbfb4189936f3e8f85dbba", + "Value": { + "$ID": "abba92dc65ef4a44a43db39f77183261", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f81b3fcbc2d2da4392472bd5bad77963", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "37091ae8ff5f754b9a440b2f0eee26b1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "7b2d0a04657d3a4b83c4f69718bf6865", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b0cb9a5c1445244996aa5d041c5d46e2", + "Value": { + "$ID": "9003add6460c1c41984773aa29b235bb", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4aa7038de6e28e408425849f6e881c07", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "action", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9102a561abfb7247b82510defdb0a37c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9c14254033aef8418823ffb4d65cb5b5", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "119ee368b406da469db566924cd2fb6a", + "Value": { + "$ID": "a28af88dfa88ee438aac0a55423f2c25", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f1b848eb3f15cf4d86686fb9e6d8e385", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "77c484b65daf6048acc8f737cdacebcd", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "37e6facfcdec6a4f943d1009ca014b2b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "029368a3a74710489a13da99ce478240", + "Value": { + "$ID": "c4d0864f728228478a12ca179c0d10fd", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4671324aa7684b43a3a76d089d3b3637", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "94afc22a317ec840b54bc8e96e01bcf0", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "6a9cc0827629d84fab198a4cd50ef391", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "8d60faa4ef3b7543b27a4c7e8ac599c2", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "05b166fa6aa069418e5ebb5b983088de", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "918eeaa25eb5ab4e83b23b36cfd1c64a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "373ae74fabec9649a3c03a854069addd", + "Value": { + "$ID": "c897788cd37a6647adfbd75d6c03217d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ad8278f1bba9e94ba874f45749e28826", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "pixels", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6f0257533618ed4682c9d04f6bc1a694", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6d4eddfeb37c2a4fb918d91818d86282", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6c8ac20a68229e409c82f61a01d538a7", + "Value": { + "$ID": "2e57f6359ffcb541aaf0ca9356b64499", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "309221f8b9cea54195644c7dbb93d44f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "48", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5c80c4caf491e04b969a5ad0e968c989", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2c07823b6115814bb5357fc2ee1a0673", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "342f42fc717ecd4583ac0adee455f856", + "Value": { + "$ID": "cb8d1dc360fc6e478e2ae6b5a7e9318b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7b5eb6df8fe7a4448fce72e06fff81e3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "pixels", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6c617254aa5ae748b4862be2be0d91c9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6db0cae2776ec3418da7154257987760", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e55d1ca4d2416c4493edadd8828e97b9", + "Value": { + "$ID": "d510367b2cedae4f97537545c69ffce0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c1801c50dd554a4498caa6f3c4d77dc2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "48", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e5ccd6ff00f1ee41ba0ced13363d8bb2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0b9b9a79f3a69845964196afb2edddbd", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "835eb7e24ad07540aacac90fff04b16a", + "Value": { + "$ID": "9836c2ce60555044b78b05e4c037cdb3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "dd10acd27f25044390ddc413be69cf3c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "14", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a24643418b05924d83ff52ef2b94b51a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e46415534a5d124c99462ea3bf29f166", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b1d78e6f38172246b34bf18b32aac5ff", + "Value": { + "$ID": "f362a799b23a4147b7c24f819076fd26", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "96a35a312a789f4f9b866ccc611783ad", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "fullImage", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7f455951988bb2499abe6f15db58198e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b4c021259b532544ae7aa1ea17af1f72", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9f4a640cf127854bb1955402f58f6f26", + "Value": { + "$ID": "494d1f234610c447aef1eeb4104bd512", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3efb83944a7a154f8fcc008e5d7be59e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9f9a68ac89a29d49be711ff0121babcf", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b88a748649cd8741afb583a50d8dc9d2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "64c294227bd8fa44a24a13f3139f2b60", + "Value": { + "$ID": "01c687e557873f40b3b00cfe68068200", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e8c5e3b84f154148a4aecc0dbf0a8ac0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "none", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f5c971ab64c75149a3d08088ba247b89", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8d5c4651bbe2094abc854745d2450dfb", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "bb55df209b1bcc419947015ac78d5fdf", + "Value": { + "$ID": "81d2e7b4ceedfa4a8fcf121169b77d39", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6f4530a418c2244ba6e53039aeb04366", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "0", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "3db4c4ccf18aba47826900425c43f58a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "46e2b9957496f24aa92eb78fdf42742b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "387aa3a68c56224ba20951049f16d65b", + "Value": { + "$ID": "ca4f9382337a6a46b1690b9f88d9e06d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2a9d6d6707eff943b957eab45f2d30e2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "none", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e6f0536b38105d4295165240ea45c367", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "3b13006cbd73ec49afe1f4008bc36bd2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "95a9e329b3930b46bd3d7d03251b12de", + "Value": { + "$ID": "74dc9aefe56f844a81dea90e72755055", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "cdc12b480dc91549b9c04f5dd5daf04d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "0", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d1c636c524a8bb4f920665d82f274744", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "01e4afa97296fd4b91f4a801c99e786f" + }, + "type": { + "$ID": "5feeafa1434eba43b975997eec53a6e8", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/image", + "ObjectType": { + "$ID": "01e4afa97296fd4b91f4a801c99e786f", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "330eee71236a1141b08f97a07bbf0aa7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Image type", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "datasource", + "ValueType": { + "$ID": "229fbed960b1b44abf1f5c60f841a6b1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "image", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "1d1ffebaefae8d499339326fe19977b7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Image", + "_Key": "image" + }, + { + "$ID": "80c76446a36e1e40b5c15ebbfa55a6fb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Image URL", + "_Key": "imageUrl" + }, + { + "$ID": "38c6e40a46468f45bb6229109a7e8e99", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Icon", + "_Key": "icon" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "fbe1c66d9c58a841a0524bee96d1439c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Image source", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "imageObject", + "ValueType": { + "$ID": "f3dc55b77449104fb21710616e882e9d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Image" + } + }, + { + "$ID": "e95a1541bb9b804791d2260857574667", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Default image", + "Category": "General::Data source", + "Description": "This is the image that is displayed if no image is uploaded.", + "IsDefault": false, + "PropertyKey": "defaultImageDynamic", + "ValueType": { + "$ID": "8390dbb64833bb4eabb8c47b305fdcf8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Image" + } + }, + { + "$ID": "c32d2226de4b5a4cb5db08f7c8e7244b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Image URL", + "Category": "General::Data source", + "Description": "The link of the external image.", + "IsDefault": false, + "PropertyKey": "imageUrl", + "ValueType": { + "$ID": "202df245462c814c8372526b9f1fc855", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "68836e20ef627848b2d7bddafd91c8be", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Icon", + "Category": "General::Data source", + "Description": "The icon image.", + "IsDefault": false, + "PropertyKey": "imageIcon", + "ValueType": { + "$ID": "6f23b6f705cccc459e50276f2ccd914f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Icon" + } + }, + { + "$ID": "956c814e28c1604eabdb9d7548fc7bff", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Background image", + "Category": "General::Data source", + "Description": "Whether the image is rendered as a background. More content can be put inside, while design properties will have no effect.", + "IsDefault": false, + "PropertyKey": "isBackgroundImage", + "ValueType": { + "$ID": "ae54b0987393784e8a09a6d3e61e8292", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "bdf5007e0afbfb4189936f3e8f85dbba", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Place content here", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "children", + "ValueType": { + "$ID": "37091ae8ff5f754b9a440b2f0eee26b1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "b0cb9a5c1445244996aa5d041c5d46e2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click type", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClickType", + "ValueType": { + "$ID": "9102a561abfb7247b82510defdb0a37c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "action", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "c0e75f77455f9e41849a747c90a1ea67", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Action", + "_Key": "action" + }, + { + "$ID": "199dd135b3637344847e27fe41b69945", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Enlarge", + "_Key": "enlarge" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "119ee368b406da469db566924cd2fb6a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClick", + "ValueType": { + "$ID": "77c484b65daf6048acc8f737cdacebcd", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "029368a3a74710489a13da99ce478240", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Alternative text", + "Category": "General::Accessibility", + "Description": "Alternative text of the image for accessibility purposes.", + "IsDefault": false, + "PropertyKey": "alternativeText", + "ValueType": { + "$ID": "05b166fa6aa069418e5ebb5b983088de", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "6f547135d200034bb5d167f9958536a7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Conditional Visibility", + "Description": "", + "IsDefault": false, + "PropertyKey": "Name", + "ValueType": { + "$ID": "a7de920db452f3439f66b407a798b27e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "7c043cb9ab7b7f4da53e330b429963f0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Conditional Visibility", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "97cf20815b93c643bad05e8e3203cb43", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "373ae74fabec9649a3c03a854069addd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Width unit", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "widthUnit", + "ValueType": { + "$ID": "6f0257533618ed4682c9d04f6bc1a694", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "auto", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "6f5eda4792f8e041b081037302685053", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto", + "_Key": "auto" + }, + { + "$ID": "da2629ca4d440a45b52b6f2353674fdc", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Pixels", + "_Key": "pixels" + }, + { + "$ID": "786b2f95bad01d48a5c2865ae8ad27bc", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Percentage", + "_Key": "percentage" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "6c8ac20a68229e409c82f61a01d538a7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Width", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "width", + "ValueType": { + "$ID": "5c80c4caf491e04b969a5ad0e968c989", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "342f42fc717ecd4583ac0adee455f856", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height unit", + "Category": "Dimensions::Dimensions", + "Description": "Auto will keep the aspect ratio of the image.", + "IsDefault": false, + "PropertyKey": "heightUnit", + "ValueType": { + "$ID": "6c617254aa5ae748b4862be2be0d91c9", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "auto", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "90d0f3a774eb5d408f2d6d7168c02cbb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Auto", + "_Key": "auto" + }, + { + "$ID": "576514512ff98f4a99b2e31f140eb0a6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Pixels", + "_Key": "pixels" + }, + { + "$ID": "4da70e47928a344bab9d9cf9beddabf9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Percentage", + "_Key": "percentage" + }, + { + "$ID": "49fb5f943873a94bb2b2a1a11a020e30", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Viewport", + "_Key": "viewport" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "e55d1ca4d2416c4493edadd8828e97b9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "height", + "ValueType": { + "$ID": "e5ccd6ff00f1ee41ba0ced13363d8bb2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "64c294227bd8fa44a24a13f3139f2b60", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum Height unit", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "minHeightUnit", + "ValueType": { + "$ID": "f5c971ab64c75149a3d08088ba247b89", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "none", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "e7703d0eac0c4d47a4536984e547e06f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "None", + "_Key": "none" + }, + { + "$ID": "4c6d23b0c67eea41a37cb62aab82def1", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Pixels", + "_Key": "pixels" + }, + { + "$ID": "bf3e9e3e46092b43adc7da32540457ae", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Percentage", + "_Key": "percentage" + }, + { + "$ID": "e491ff212f0e3341a78aa1eb1cea97a2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Viewport", + "_Key": "viewport" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "bb55df209b1bcc419947015ac78d5fdf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum height", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "minHeight", + "ValueType": { + "$ID": "3db4c4ccf18aba47826900425c43f58a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "0", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "387aa3a68c56224ba20951049f16d65b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum Height unit", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "maxHeightUnit", + "ValueType": { + "$ID": "e6f0536b38105d4295165240ea45c367", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "none", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "4317b2c2e383c1479e2e66b2f3e193d9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "None", + "_Key": "none" + }, + { + "$ID": "1626a4c715d1a4408f8e57f8c35e6aca", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Pixels", + "_Key": "pixels" + }, + { + "$ID": "d2c65c9f52c9f84489e8497878b888c3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Percentage", + "_Key": "percentage" + }, + { + "$ID": "813e9e17159b464d824f1109083a904f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Viewport", + "_Key": "viewport" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "95a9e329b3930b46bd3d7d03251b12de", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum height", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "maxHeight", + "ValueType": { + "$ID": "d1c636c524a8bb4f920665d82f274744", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "0", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "835eb7e24ad07540aacac90fff04b16a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Icon size", + "Category": "Dimensions::Dimensions", + "Description": "The size of the icon in pixels.", + "IsDefault": false, + "PropertyKey": "iconSize", + "ValueType": { + "$ID": "a24643418b05924d83ff52ef2b94b51a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "14", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "b1d78e6f38172246b34bf18b32aac5ff", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "displayAs", + "ValueType": { + "$ID": "7f455951988bb2499abe6f15db58198e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "fullImage", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "cfc5ebfbd5e9714bb100c4c94184afd7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Full image", + "_Key": "fullImage" + }, + { + "$ID": "dbfb5eeb59a8fc4faa909f540095af21", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "Caption": "Thumbnail", + "_Key": "thumbnail" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "9f4a640cf127854bb1955402f58f6f26", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Responsive", + "Category": "Dimensions::Dimensions", + "Description": "Image will never get larger than its original size. It can become smaller.", + "IsDefault": false, + "PropertyKey": "responsive", + "ValueType": { + "$ID": "9f9a68ac89a29d49be711ff0121babcf", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowNonPersistableEntities": false, + "AllowUpload": false, + "AllowedTypes": [ + 1 + ], + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Images, Videos & Files", + "StudioProCategory": "Images, videos & files", + "SupportedPlatform": "Web", + "WidgetDescription": "Display an image and enlarge it on click.", + "WidgetId": "com.mendix.widget.web.image.Image", + "WidgetName": "Image", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "version": "11.8.0", + "widgetId": "com.mendix.widget.web.image.Image" +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/languageselector.json b/modelsdk/widgets/templates/mendix-11.6/languageselector.json new file mode 100644 index 00000000..fc62e87b --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/languageselector.json @@ -0,0 +1,614 @@ +{ + "widgetId": "com.mendix.widget.web.languageselector.LanguageSelector", + "name": "Language selector", + "version": "11.6.4", + "extractedFrom": "5348da5f-bef0-44ff-abbe-4d1364158f8a", + "type": { + "$ID": "48240cf99fad4691a8c3f54fd911770e", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/languageSelector", + "ObjectType": { + "$ID": "6347e118092b46e1a6a5eb838ef329ed", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "05feafd261b24295a376e30348869393", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Data source", + "Category": "General::Languages", + "Description": "Recommended: Database data source with System.Language as entity.", + "IsDefault": false, + "PropertyKey": "languageOptions", + "ValueType": { + "$ID": "6633ecfa09e0433497781d69e2b51ecb", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "ebc68c2ad5aa4eacb5417cc5639a1863", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Language caption", + "Category": "General::Languages", + "Description": "Recommended: $currentObject/Description.", + "IsDefault": false, + "PropertyKey": "languageCaption", + "ValueType": { + "$ID": "418907e112e64436a84a422c6dd64524", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "languageOptions", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": { + "$ID": "087fc6d252bc47779501778a22b9b8ef", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "da0d53f094fc45e89b344518ecec05cc", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Menu position", + "Category": "General::General", + "Description": "The location of the menu relative to the current selected language (click area).", + "IsDefault": false, + "PropertyKey": "position", + "ValueType": { + "$ID": "bd10b1cb65dd4cec99e745c057a2da3b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "bottom", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "0798040cbcef47999232a54f48b02b91", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "left", + "Caption": "Left" + }, + { + "$ID": "1dcf1b7ab82846db9f1647835b862361", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "right", + "Caption": "Right" + }, + { + "$ID": "777afbb376794471a86e33918e7ad632", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "top", + "Caption": "Top" + }, + { + "$ID": "69ccf32469854a148c9876478fe28f02", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "bottom", + "Caption": "Bottom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "bc670b5465bc4230b800c91d86f45b22", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Open menu on", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "trigger", + "ValueType": { + "$ID": "2d7df91b2e4f4e0e9e1f396b673a82fa", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "click", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "c1d6c282314345568f05c6959e76fb89", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "click", + "Caption": "Click" + }, + { + "$ID": "b92225a0cf744022af338df99a51a259", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "hover", + "Caption": "Hover" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "c9a33da70cc44373a4f13da3bb201775", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Hide for single language", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "hideForSingle", + "ValueType": { + "$ID": "f683ce4a2c164b23960a258f29c959da", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "93060ff899854bee903edf598ac8bb7e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Label caption", + "Category": "Accessibility::Accessibility", + "Description": "Assistive technology will read this upon reaching the input element.", + "IsDefault": false, + "PropertyKey": "screenReaderLabelCaption", + "ValueType": { + "$ID": "da2843955a574165bb65817b022c979a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Display", + "StudioProCategory": "Display", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.languageselector.LanguageSelector", + "WidgetName": "Language selector", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "f520c6ac32d34ce5bbe02c9751e191ac", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "9a6f92c6c65d4a1680f896084a307cf5", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "05feafd261b24295a376e30348869393", + "Value": { + "$ID": "3266864c926c46b8b1456ef4fa99bfed", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "525c1ac4607e486da96076f54223070f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6633ecfa09e0433497781d69e2b51ecb", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5e3a9fa2e21a46e9ad37654e9d42dd57", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ebc68c2ad5aa4eacb5417cc5639a1863", + "Value": { + "$ID": "6064ff39cd0e42cf873ad004cee1060f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f15459de79254b22973b6a830eb06668", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "418907e112e64436a84a422c6dd64524", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "44ae987c3b1d4fa89e736995ee5dbddb", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "da0d53f094fc45e89b344518ecec05cc", + "Value": { + "$ID": "d05793fe02a040d48ba205000d2fca00", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "db7618670a6b4f36a612a018454d4d81", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "bottom", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "bd10b1cb65dd4cec99e745c057a2da3b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5b3bfe06796744bab341fb9d95d02311", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "bc670b5465bc4230b800c91d86f45b22", + "Value": { + "$ID": "aff75f1c379a4119b39dc525d0ab2209", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "585203e4f24b46769076cbfcf6fdf240", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "click", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2d7df91b2e4f4e0e9e1f396b673a82fa", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f064b115eae84c49a63f59ee8a367b9c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c9a33da70cc44373a4f13da3bb201775", + "Value": { + "$ID": "1ddca95edb9f4e28b46122831bdad726", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7f23f548b4004f92bf52313f80f3b20d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f683ce4a2c164b23960a258f29c959da", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c50f54ee83784623b2b7441b6540955b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "93060ff899854bee903edf598ac8bb7e", + "Value": { + "$ID": "1fa5bb133ff8418f8e1a42dbde8005f8", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ffd1fffae8404309b48f2116e96ada68", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "777d7d7cd44c45d1abe89ad8738c282a", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "1931aaa9f5d64b6bbc3859db75a15442", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "123f7b3050fa4559a4dd656c281b3dc1", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "da2843955a574165bb65817b022c979a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "6347e118092b46e1a6a5eb838ef329ed" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/maps.json b/modelsdk/widgets/templates/mendix-11.6/maps.json new file mode 100644 index 00000000..cccfe021 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/maps.json @@ -0,0 +1,3031 @@ +{ + "widgetId": "com.mendix.widget.custom.Maps.Maps", + "name": "Maps", + "version": "11.6.4", + "extractedFrom": "ad99db47-e255-4c75-a357-b4a640b8102d", + "type": { + "$ID": "e61e8793c7a94d25834a0f978312b045", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/maps", + "ObjectType": { + "$ID": "79d8d2282f5848d8ad35b780bc0d626d", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "c1627ee4cd764d80bbb304a2a64b19a3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Enable advanced options", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "advanced", + "ValueType": { + "$ID": "5062ba1991f14b2bb9a655b5840171d5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "96bb496725da4cbb80c39ecd84d3d57b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Marker", + "Category": "General::Markers", + "Description": "A list of static locations on the map.", + "IsDefault": false, + "PropertyKey": "markers", + "ValueType": { + "$ID": "c2c4645da38a4a5bad2e7865e33c7da6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "7e88d1ced1124310915c90c8b58fba37", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "e74c28433232473893b079f9fec0dde2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Location", + "Category": "Locations::Location", + "Description": "", + "IsDefault": false, + "PropertyKey": "locationType", + "ValueType": { + "$ID": "4e08ffb2193f45878205102161071c1a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "address", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "de5a5117db2745028cd5fe2e402da47d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "address", + "Caption": "Based on address" + }, + { + "$ID": "9b5c189ca0754ee2a917205ba07cbbe5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "latlng", + "Caption": "Based on latitude and longitude" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "2f610d5da874430cb9a3c5b99770f08e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Address", + "Category": "Locations::Location", + "Description": "Address containing (a subset of) street, number, zipcode, city and country.", + "IsDefault": false, + "PropertyKey": "address", + "ValueType": { + "$ID": "89d2ef821da84894a74332596b298b2a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "4a1871948275470db6a562922106e436", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Latitude", + "Category": "Locations::Location", + "Description": "Decimal number from -90.0 to 90.0.", + "IsDefault": false, + "PropertyKey": "latitude", + "ValueType": { + "$ID": "095e918d8ebe4868b1af1eb68aa25346", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "44a2b1455b4947649206176361e5bef8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Longitude", + "Category": "Locations::Location", + "Description": "Decimal number from -180.0 to 180.0.", + "IsDefault": false, + "PropertyKey": "longitude", + "ValueType": { + "$ID": "5248445486544bfb98710db09c83703c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "283556f9c8a94f678dd8c389880fbd35", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Title", + "Category": "Locations::Location", + "Description": "Title displayed when clicking the marker.", + "IsDefault": false, + "PropertyKey": "title", + "ValueType": { + "$ID": "4c8515c6e07c4522b286144a714337dd", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "9fbb9d7549494d07a55b3a9aed708167", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click", + "Category": "Locations::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClick", + "ValueType": { + "$ID": "9fcc18431d6a4eeaae1205f9b3f9093b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "a40f4f0eb7944204ad16975934c40ca4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Marker style", + "Category": "Locations::Visualization", + "Description": "", + "IsDefault": false, + "PropertyKey": "markerStyle", + "ValueType": { + "$ID": "56fb8e9dcc7b4d41a3d76376fdbd1d3f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "default", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "8403f7729afd4bcb87904c9e0c40158c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "default", + "Caption": "Default" + }, + { + "$ID": "9f2daa9fb6634de6bab7ba831720f1e8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "image", + "Caption": "Image" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "6678dc68ff18466d83c76c55efea60c3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Image", + "Category": "Locations::Visualization", + "Description": "Image that replaces the default icon.", + "IsDefault": false, + "PropertyKey": "customMarker", + "ValueType": { + "$ID": "fe8dd0ac375e439980e93212ee6f0ce6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Image" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "efde290a2f9145d6bfa7acb2ade8a990", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Marker list", + "Category": "General::Markers", + "Description": "A list of markers showing dynamic locations on the map.", + "IsDefault": false, + "PropertyKey": "dynamicMarkers", + "ValueType": { + "$ID": "14d5bef75ec94db1995e8200dcb13e28", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "25cc64bda3c0419896de07f5eaca16bd", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "f2553e0260084d0b918475ec73b61bf7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Data source", + "Category": "Locations::Location", + "Description": "", + "IsDefault": false, + "PropertyKey": "markersDS", + "ValueType": { + "$ID": "c750addd81fa4bfe8bf1dfe5b8819a23", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "acc98270cc024bcf80ba0b2c91154375", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Location", + "Category": "Locations::Location", + "Description": "", + "IsDefault": false, + "PropertyKey": "locationType", + "ValueType": { + "$ID": "9281c7c4146d44ba897571c8221b079b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "address", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "030f654f211c4791892a054697a6ce00", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "address", + "Caption": "Based on address" + }, + { + "$ID": "ec0b1ac3f25b449694a011e25feed4d3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "latlng", + "Caption": "Based on latitude and longitude" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "4b719379959e4defbb8c2bf003d2f857", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Address", + "Category": "Locations::Location", + "Description": "Address containing (a subset of) street, number, zipcode, city and country.", + "IsDefault": false, + "PropertyKey": "address", + "ValueType": { + "$ID": "ac417c9d9a754c278b02ba1d384873a8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "String" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "markersDS", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "6cb234f97b7748e4ad05c286f828339d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Latitude", + "Category": "Locations::Location", + "Description": "Decimal number from -90.0 to 90.0.", + "IsDefault": false, + "PropertyKey": "latitude", + "ValueType": { + "$ID": "2d74ea55bd1d4a15b4fac70072d82450", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Decimal" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "markersDS", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "fe2bdfeea0134d64aec3a3e39472d53d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Longitude", + "Category": "Locations::Location", + "Description": "Decimal number from -180.0 to 180.0.", + "IsDefault": false, + "PropertyKey": "longitude", + "ValueType": { + "$ID": "70f9675d7db249b49308f170f434b08c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Decimal" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "markersDS", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "ad0f39400dd14fde9d301de627238f8a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Title", + "Category": "Locations::Location", + "Description": "Title displayed when clicking the marker.", + "IsDefault": false, + "PropertyKey": "title", + "ValueType": { + "$ID": "893441c419fc4084972b9e7c15afe724", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "String" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "markersDS", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "c5203f159a99476c815d8c4e14f62ac6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click", + "Category": "Locations::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClickAttribute", + "ValueType": { + "$ID": "f42c1d09b74644c78b43db7234bd5af0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "markersDS", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "68bf93cfb19947cfaaa17dca3bbebddc", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Marker style", + "Category": "Locations::Visualization", + "Description": "", + "IsDefault": false, + "PropertyKey": "markerStyleDynamic", + "ValueType": { + "$ID": "4ff0d328eba84d7b8f29d2e36b2c2d5e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "default", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "b98c24a7b9054693af6cf61badccf526", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "default", + "Caption": "Default" + }, + { + "$ID": "2af857f04ad9453eb12cfe5091baf41c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "image", + "Caption": "Image" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "616ae72c74f64e23adede6010e90e0ef", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Image", + "Category": "Locations::Visualization", + "Description": "Image that replaces the default icon.", + "IsDefault": false, + "PropertyKey": "customMarkerDynamic", + "ValueType": { + "$ID": "7cf49c660afa49509d62442f7a485a18", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Image" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "b6136d0be7a340518187169ec00b465d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "API Key", + "Category": "General::Configurations", + "Description": "API Key for usage of the map through the selected provider.Google Maps - https://developers.google.com/maps/documentation/javascript/get-api-key Map Box - https://docs.mapbox.com/help/getting-started/access-tokens/ Here Maps - https://developer.here.com/tutorials/getting-here-credentials/", + "IsDefault": false, + "PropertyKey": "apiKey", + "ValueType": { + "$ID": "09be00d8f1224d1780e01f809cede4f1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + }, + { + "$ID": "1c59d9d6a67047c5a40e6fc8b978a52d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "API Key", + "Category": "General::Configurations", + "Description": "API Key for usage of the map through the selected provider.Google Maps - https://developers.google.com/maps/documentation/javascript/get-api-key Map Box - https://docs.mapbox.com/help/getting-started/access-tokens/ Here Maps - https://developer.here.com/tutorials/getting-here-credentials/", + "IsDefault": false, + "PropertyKey": "apiKeyExp", + "ValueType": { + "$ID": "1d0ca1807b7a4c188901b1001a93d843", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "bb062c94387c42a0987fae1806890976", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "1fc75220f0094e6aacdbc7359d1763e0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Geo location API key", + "Category": "General::Configurations", + "Description": "Used to translate addresses to latitude and longitude. This API Key should be a Google Geocoding API Key found in https://developers.google.com/maps/documentation/geocoding/overview", + "IsDefault": false, + "PropertyKey": "geodecodeApiKey", + "ValueType": { + "$ID": "f0ba21e99e7a4956822a0af45241f80c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + }, + { + "$ID": "0d23929280b44d4b96f4fe2506565269", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Geo location API key", + "Category": "General::Configurations", + "Description": "Used to translate addresses to latitude and longitude. This API Key should be a Google Geocoding API Key found in https://developers.google.com/maps/documentation/geocoding/overview", + "IsDefault": false, + "PropertyKey": "geodecodeApiKeyExp", + "ValueType": { + "$ID": "01f318fdbcb74b3c96f4123991443967", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "82f6edf49ecd47d689df367f089a618b", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "3e446fd397b542f58292fdc09dd2fcdb", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show current location marker", + "Category": "General::Configurations", + "Description": "Shows the user current location marker.", + "IsDefault": false, + "PropertyKey": "showCurrentLocation", + "ValueType": { + "$ID": "a28bc879e4c34593a3e6878c351f4ca9", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "3c9ebc02957344339dec23e766471396", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Drag", + "Category": "Controls::General", + "Description": "The center will move when end-users drag the map.", + "IsDefault": false, + "PropertyKey": "optionDrag", + "ValueType": { + "$ID": "fefaf6ed6f80470b8a6fcd9b8a9b7c94", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "f8bb3d60a7af4d9397360938fe798fb0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Scroll to zoom", + "Category": "Controls::General", + "Description": "The map is zoomed with a mouse scroll.", + "IsDefault": false, + "PropertyKey": "optionScroll", + "ValueType": { + "$ID": "e5662314569345b1803fb73d7c4ab430", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "935e370a95464770bf6ab8d29ed447ef", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Zoom", + "Category": "Controls::General", + "Description": "Show zoom controls [ + ] [ - ].", + "IsDefault": false, + "PropertyKey": "optionZoomControl", + "ValueType": { + "$ID": "b0b80411e3124191a92100cbe93e3db8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "618c187a7d9444cd99c058239bd1e44d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribution control", + "Category": "Controls::General", + "Description": "Add attributions to the map (credits).", + "IsDefault": false, + "PropertyKey": "attributionControl", + "ValueType": { + "$ID": "d5bb7676542f43388ccc3dfc718e552a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "4382be42783e472188087566985ea82e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Street view", + "Category": "Controls::General", + "Description": "Enables the Street View control.", + "IsDefault": false, + "PropertyKey": "optionStreetView", + "ValueType": { + "$ID": "4d014e7183f84350adf356e0841c93f1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "68761f13194f4fa78a91a933493dc79d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Map type", + "Category": "Controls::General", + "Description": "Enables switching between different map types.", + "IsDefault": false, + "PropertyKey": "mapTypeControl", + "ValueType": { + "$ID": "faa643358be24c8f9fc1e6a0c9931a99", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "74e1a477405a428aaa7c171040ded18d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Full screen", + "Category": "Controls::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "fullScreenControl", + "ValueType": { + "$ID": "4b80cff0ad2542da9471af0dde5a7ce0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "28459429a6c84171a985e7ab12ae5b15", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Rotate", + "Category": "Controls::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "rotateControl", + "ValueType": { + "$ID": "8aeac75979f441a9a859d2220a6987e4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "fbee14175814430081d1838607fe598c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Width unit", + "Category": "Dimensions::Dimensions", + "Description": "Percentage: portion of parent size. Pixels: absolute amount of pixels.", + "IsDefault": false, + "PropertyKey": "widthUnit", + "ValueType": { + "$ID": "261f821d00864615bd250604183f8088", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "percentage", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "b987d91471794413b51dd88cd5e31a8a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentage", + "Caption": "Percentage" + }, + { + "$ID": "10f6e81523214840884bd69210154c90", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "pixels", + "Caption": "Pixels" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "a3891f06592d4eb2b4ab58a6708f135b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Width", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "width", + "ValueType": { + "$ID": "82e33d7c012e4890bfc90069f764f474", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "29dad9f049d8488d9baa6b6269152d87", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height unit", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "heightUnit", + "ValueType": { + "$ID": "fb10229a44ea4bf38317da9e0abcdeef", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "percentageOfWidth", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "6780c46a3a184c419198ac36ab0a43dd", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentageOfWidth", + "Caption": "Percentage of width" + }, + { + "$ID": "63ccf957b54745138583ec889925be05", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "pixels", + "Caption": "Pixels" + }, + { + "$ID": "14d71a46c95c42798788443e1322eeb6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentageOfParent", + "Caption": "Percentage of parent" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "ea79bfe2b31c4624b96fd3ff0e65711e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "height", + "ValueType": { + "$ID": "9a51e03cde754a299d811b1f2282a0ad", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "75", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "bf5c7591417440148511fc0f6bf85a45", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Zoom level", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "zoom", + "ValueType": { + "$ID": "8827712fc9334098bea294b6d9bb1e20", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "automatic", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "03d8de308c9a43c18fe7d68277bca9ec", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "automatic", + "Caption": "Automatic" + }, + { + "$ID": "4d0b99816dfa458a8a8ecce691b3433f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "world", + "Caption": "World" + }, + { + "$ID": "ff5ab1ff9fef4f039e97b566b718949c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "continent", + "Caption": "Continent" + }, + { + "$ID": "3b19e53d94e6405cb4a0289d9dbd3064", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "city", + "Caption": "City" + }, + { + "$ID": "42c9010bd63747a49250fd0eb0e55659", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "street", + "Caption": "Street" + }, + { + "$ID": "96f24b2db1ac40929aac0992aa07407b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "buildings", + "Caption": "Buildings" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "d5a6fb461ece46e3a3beee3b75828965", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Map provider", + "Category": "Advanced::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "mapProvider", + "ValueType": { + "$ID": "bd04a24174a645f8843b6dbcdeb2343f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "googleMaps", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "856dc481ceab479f896b5494ae630f86", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "googleMaps", + "Caption": "Google Maps" + }, + { + "$ID": "ff72b6e7008b47278342c4e8efaa9c79", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "openStreet", + "Caption": "Open street" + }, + { + "$ID": "53b11afb6ed148a7a7bdf684ec99c009", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "mapBox", + "Caption": "Map box" + }, + { + "$ID": "61b9e617077449678e1beced5793e54b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "hereMaps", + "Caption": "Here Maps" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "812fcdda6cfe4725825271a11ed4bf40", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Google MapId key", + "Category": "Advanced::General", + "Description": "Used to render and style the Google map. This MapId key from Google can be found in https://developers.google.com/maps/documentation/get-map-id", + "IsDefault": false, + "PropertyKey": "googleMapId", + "ValueType": { + "$ID": "d9b6b067fb74419d8c0884faffe79c30", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "String" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Display", + "StudioProCategory": "Display", + "SupportedPlatform": "Web", + "WidgetDescription": "Custom description please", + "WidgetId": "com.mendix.widget.custom.Maps.Maps", + "WidgetName": "Maps", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "58a5cd1f2d5e467abc707e6be92a3a33", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "d8b26ae66d1941a59db1c3831f1f9ed7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c1627ee4cd764d80bbb304a2a64b19a3", + "Value": { + "$ID": "873cd45e09e345139c82dfd9fcf9666b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2b6917c46b7044689bdbbca85571a374", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5062ba1991f14b2bb9a655b5840171d5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cac2f8d11a03428ba337a170ff5c7d47", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "96bb496725da4cbb80c39ecd84d3d57b", + "Value": { + "$ID": "679a04c9167c40f585b0abd9ba63abc3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f6facb452e464f89af6b26ffdcc5194e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c2c4645da38a4a5bad2e7865e33c7da6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "459d7ba94dd342578e51ad58633ab5fc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "efde290a2f9145d6bfa7acb2ade8a990", + "Value": { + "$ID": "c3af2c36a80c4c179042a985eba3a7d2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ca7da29e37e04981ab10c8095c150b77", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "14d5bef75ec94db1995e8200dcb13e28", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "fce7ba1c5bf54a179fa30f9fe6d319f0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b6136d0be7a340518187169ec00b465d", + "Value": { + "$ID": "88c439a5bc16427981be6ea59ebd447c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "095cc27723b249fa9dfaadccf5f0a090", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "09be00d8f1224d1780e01f809cede4f1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d63e65f8e64e412586b8e03eedda78a4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1c59d9d6a67047c5a40e6fc8b978a52d", + "Value": { + "$ID": "a16aacdace1d4cd1ba517fdd4e330021", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6ec4c6fdebdb4bcbbb0f6e62f2fa3076", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1d0ca1807b7a4c188901b1001a93d843", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8e52a7f2c47e448f974b21208b760d34", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1fc75220f0094e6aacdbc7359d1763e0", + "Value": { + "$ID": "febbd63f50744fc59210a4472b7c2c04", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "db8934e222b24b5988b31c8558fa52fa", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f0ba21e99e7a4956822a0af45241f80c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "34144aa567c641a08d4bde4853900063", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "0d23929280b44d4b96f4fe2506565269", + "Value": { + "$ID": "44afd7c7b0ec44d69e7791be17ee4b97", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6c862544dc4d4edfb69ba81675ad6b93", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "01f318fdbcb74b3c96f4123991443967", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "30ddcab2c7a241eb932c4bfa40571aa3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3e446fd397b542f58292fdc09dd2fcdb", + "Value": { + "$ID": "4c4ffb7f683045bf94949450ed80c5f5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "21ee2bcad0a7497daba365df4cf08c9e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a28bc879e4c34593a3e6878c351f4ca9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ce061d692ef54fa180dfa9c87477032a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3c9ebc02957344339dec23e766471396", + "Value": { + "$ID": "de2c411932d54813812a1ce64a5a452a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "fbff272c0faf4036a59dfddc81b456b9", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fefaf6ed6f80470b8a6fcd9b8a9b7c94", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "327756d8691a47d7865493666198998a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f8bb3d60a7af4d9397360938fe798fb0", + "Value": { + "$ID": "5b61a338ad02434ebb57a2ac7fe4103d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2b259e4b38454ff29dcc5c347869c56b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e5662314569345b1803fb73d7c4ab430", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6f21e41161af48e9a34e95f885fe022b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "935e370a95464770bf6ab8d29ed447ef", + "Value": { + "$ID": "0a5817196d194b1ca122691adb7ebdd1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "296c0a24acdb4bda8f869998d240573a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b0b80411e3124191a92100cbe93e3db8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "dc7a8a9e02e4463cbf55edf2cb3b5e0d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "618c187a7d9444cd99c058239bd1e44d", + "Value": { + "$ID": "3cdffcd747a04727ae996166d2056a1f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4c3759dfd7e44ac9948805d0182b4985", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d5bb7676542f43388ccc3dfc718e552a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "072b4f2734164a33be80fd49b7e72a1d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4382be42783e472188087566985ea82e", + "Value": { + "$ID": "0bcca54534254692a1073a675d453879", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "efb23c6dd57644bdb9c17012fb486b37", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4d014e7183f84350adf356e0841c93f1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6f981973417f4a9d8cb7413c589c1818", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "68761f13194f4fa78a91a933493dc79d", + "Value": { + "$ID": "e10daa96916f4c819e87a7420f49902b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5ea33f32520745639aa928b06edb1212", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "faa643358be24c8f9fc1e6a0c9931a99", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "49566206770540f6824dd4ef95190800", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "74e1a477405a428aaa7c171040ded18d", + "Value": { + "$ID": "09b4c2cb078f48dba7babe3614b11e5a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "37fd52c0684f4dcf851a97c533e5cfd6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4b80cff0ad2542da9471af0dde5a7ce0", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "167982da695e4cbfaee56a39d7fad4ca", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "28459429a6c84171a985e7ab12ae5b15", + "Value": { + "$ID": "11420c33447f4f61a508964f8c6623f6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a98ccce1fc0e4f04bd8d8e5f1e1c4539", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8aeac75979f441a9a859d2220a6987e4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d36253ff50744d638b7461e4ef34ec68", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "fbee14175814430081d1838607fe598c", + "Value": { + "$ID": "2954c10af76c468bad0bfc79ca610f5b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ff23953a6720453f9d46c7f4d2b2e992", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "percentage", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "261f821d00864615bd250604183f8088", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4dea1608d3e2443183b4d78029f89eeb", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a3891f06592d4eb2b4ab58a6708f135b", + "Value": { + "$ID": "ff3c9b05979549fb947c0297dd8a8c1a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7e51efb5db7b4a3dbb5855210cc9b89f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "82e33d7c012e4890bfc90069f764f474", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "725a05a65eef4ce69b525783e8d4c6ab", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "29dad9f049d8488d9baa6b6269152d87", + "Value": { + "$ID": "22af459b5b674def90d0c5476bd1d955", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "92ad3a9fbc18483596da8c79b59fe723", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "percentageOfWidth", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fb10229a44ea4bf38317da9e0abcdeef", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5cd516c4312e4496a31773ea22206db2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ea79bfe2b31c4624b96fd3ff0e65711e", + "Value": { + "$ID": "ac7baee8eb2947eba81ca4d5161b275a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7af7b8cfc6094269a55d7f0a9d120439", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "75", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9a51e03cde754a299d811b1f2282a0ad", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "842d39d790fe4524b7c749d67fe30fc9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "bf5c7591417440148511fc0f6bf85a45", + "Value": { + "$ID": "6386edcb8146497385e1f3a7624ac180", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0c2b524a98b141beb80076c41e8df8d8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "automatic", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8827712fc9334098bea294b6d9bb1e20", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4a02dfe6d1a84c4a8ebedf850a1be72a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d5a6fb461ece46e3a3beee3b75828965", + "Value": { + "$ID": "20e1a8f6766746e8b28db4f4ca78f213", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4bafda33f5e4465e97b03394c4ba8120", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "googleMaps", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "bd04a24174a645f8843b6dbcdeb2343f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1a0d45137448496194cd7c37f68126c6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "812fcdda6cfe4725825271a11ed4bf40", + "Value": { + "$ID": "fd33d6922d1d495f941f2f4609876564", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "bca4d68734af4aa8ba2d2b90792eec81", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d9b6b067fb74419d8c0884faffe79c30", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "79d8d2282f5848d8ad35b780bc0d626d" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/popupmenu.json b/modelsdk/widgets/templates/mendix-11.6/popupmenu.json new file mode 100644 index 00000000..c769ea25 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/popupmenu.json @@ -0,0 +1,1349 @@ +{ + "widgetId": "com.mendix.widget.web.popupmenu.PopupMenu", + "name": "Pop-up menu", + "version": "11.6.4", + "extractedFrom": "27da14a9-0df5-498a-9f15-b4624717e35c", + "type": { + "$ID": "0cac2abf934d48fa8eb4ae0f94c9b7cb", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/popup-menu", + "ObjectType": { + "$ID": "cf31d21ff453452cb5631effe3a9c05f", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "41a6ba65dae14ca092478d58a89b1158", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Enable advanced options", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "advancedMode", + "ValueType": { + "$ID": "9b72a47cf16e4506b534639c3a51f41a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "5126887f54bb4b6685de3c7330cae40f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "The area to open or close the menu.", + "Category": "General::General", + "Description": "Responsible for toggling the Pop-up menu.", + "IsDefault": false, + "PropertyKey": "menuTrigger", + "ValueType": { + "$ID": "876dc39bc17448bb871802c41d8659e0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "a6bc7768d1884abdb25dbd24949c8240", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Menu items", + "Category": "General::General", + "Description": "The popup menu items.", + "IsDefault": false, + "PropertyKey": "basicItems", + "ValueType": { + "$ID": "27728cd05caf48ad9d799686c6d57caf", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "767fbdbf9841452fa3e8826b885d6707", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "7d3bf7cf5e3a4a3ca1211e9bd9394e68", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Item type", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "itemType", + "ValueType": { + "$ID": "33faa1b3567c4bf98b9bb6b86fa2ecd8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "item", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "103561643aee4cfc8362100c06bdda09", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "item", + "Caption": "Button" + }, + { + "$ID": "ffcefd8d46b04374859321f9e1060d61", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "divider", + "Caption": "Divider" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "4be4169aed47488d894950ecbf1859a7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Caption", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "caption", + "ValueType": { + "$ID": "d669f115aa364c5cb56200d238e3fc3d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "26530ca70c4d45bfba0636d969cda398", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Visible", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "visible", + "ValueType": { + "$ID": "f79ac389d124439490f06bed685e635f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "5ffc1f747eef43ecb931acdd7a3641df", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Boolean" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "6ecb53922a8444c1ba9286cf5c893cf0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click action", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "action", + "ValueType": { + "$ID": "2ce7a9d2b8c24b39a846abbe16422ea8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "db099962d64048adb51645b24b5261d6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Style", + "Category": "General", + "Description": "An extra class will be added: \"popupmenu-basic-item-[style]\"", + "IsDefault": false, + "PropertyKey": "styleClass", + "ValueType": { + "$ID": "451760b33c844c2ab664aaba250f4383", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "defaultStyle", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "2da850865f0646289798d89dc8f4e968", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "defaultStyle", + "Caption": "Default" + }, + { + "$ID": "2b67e562d7a84ff188b329728add016a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "inverseStyle", + "Caption": "Inverse" + }, + { + "$ID": "1049be2f7df84d4b89ff1c616b762bec", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "primaryStyle", + "Caption": "Primary" + }, + { + "$ID": "2bbb2408614545bbbadde1ac95e7d362", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "infoStyle", + "Caption": "Info" + }, + { + "$ID": "156f3ca569664233b31999cd844819c8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "successStyle", + "Caption": "Success" + }, + { + "$ID": "bca7d72f6f3446c3b38ffeb4dda3a125", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "warningStyle", + "Caption": "Warning" + }, + { + "$ID": "39775715b7844f1a90e8c4e0d27bd13b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dangerStyle", + "Caption": "Danger" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "5f8a0de7b3c44063b9e1a4457ca43258", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Menu items", + "Category": "General::General", + "Description": "The popup menu custom items. To make sure the popup closes correctly after a click, do not configure clickable widgets inside the placeholders. Use the action property of this widget.", + "IsDefault": false, + "PropertyKey": "customItems", + "ValueType": { + "$ID": "25be1209611741068dcf285cf25ac33e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": { + "$ID": "5d4b37a5f76f44248e2a18cab79c303a", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "a26aeba2a68043fbb1bb1164e00aba03", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Content", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "content", + "ValueType": { + "$ID": "f0a881c2ba894e41b20ab4897ef52200", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "ad0dee6461c7444499a06432bb26971d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Visible", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "visible", + "ValueType": { + "$ID": "0840323a40bd4d6a876e9b9652793ee7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "4be7b6650a134f2f8240026bdb871971", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Boolean" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "8afd7d5ea9f14c1d9262775517eec6be", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click action", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "action", + "ValueType": { + "$ID": "6849b6340cd54a1a84d1757c8259d0fb", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + } + ] + }, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Object" + } + }, + { + "$ID": "0e2e3ab3467841f29358151494ac141f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Open on", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "trigger", + "ValueType": { + "$ID": "d66cf0302d7c48bd8ef0fe7349242d24", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "onclick", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "45fc31e7e6474595b355e618760da77c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onclick", + "Caption": "Click" + }, + { + "$ID": "99eb0ce34a0a43a3a13a2339dddee94a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onhover", + "Caption": "Hover" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "1128b00a0be3410e9e720591fa650a25", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Close on", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "hoverCloseOn", + "ValueType": { + "$ID": "cb1235ad2c6645c6ab58b9cdb331a08b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "onHoverLeave", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "af13f570ed444ca587a07c19fdcfdbd6", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onClickOutside", + "Caption": "Click outside" + }, + { + "$ID": "c2e57b6639e74f309753d3aed70b93f7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "onHoverLeave", + "Caption": "Hover leave" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "2e0ec8383923421786ecdfe348b6c037", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Menu position", + "Category": "General::General", + "Description": "The location of the menu relative to the click area.", + "IsDefault": false, + "PropertyKey": "position", + "ValueType": { + "$ID": "f0ba32b0b7564d718b5feb2de7d17cf6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "bottom", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "6b3280dac8714d98b892c177702a9b74", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "left", + "Caption": "Left" + }, + { + "$ID": "5f32d28ee17542c4ab8b80ddd2e69b70", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "right", + "Caption": "Right" + }, + { + "$ID": "d0ccb3df28264cd6b4f28e9828d4275b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "top", + "Caption": "Top" + }, + { + "$ID": "cd83fe3c0e954092b1abd6063e8a7f98", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "bottom", + "Caption": "Bottom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "0947f24837dc4955b353f50e1fed2fb9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Clipping strategy", + "Category": "General::General", + "Description": "'Absolute' positions the floating element relative to its nearest positioned ancestor, while 'Fixed' breaks it out of any clipping ancestor.", + "IsDefault": false, + "PropertyKey": "clippingStrategy", + "ValueType": { + "$ID": "fa7fb44f25cc4eb6be1d01314ca26d0d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "absolute", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "9ae8b8b2f3dd4f48a01abf5c8bebd3e4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "absolute", + "Caption": "Absolute" + }, + { + "$ID": "9f9f071ac8ab4f199fe6cc7ccec57b84", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "fixed", + "Caption": "Fixed" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "6ad862c454614a41abf53d83a0ff9717", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show preview", + "Category": "General::Development", + "Description": "Use this to see a preview of the menu items while developing.", + "IsDefault": false, + "PropertyKey": "menuToggle", + "ValueType": { + "$ID": "71b85f07db4043fe857276118603b90f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Menus", + "StudioProCategory": "Menus & navigation", + "SupportedPlatform": "Web", + "WidgetDescription": "Displays a set of pre-defined items within the Pop-up menu", + "WidgetId": "com.mendix.widget.web.popupmenu.PopupMenu", + "WidgetName": "Pop-up menu", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "d13f245d7e3d432682e885da39ae2ee3", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "c9093e7dd8274bf1a0aa3979c81f6a0d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "41a6ba65dae14ca092478d58a89b1158", + "Value": { + "$ID": "a284fc347e5940749843e4a349b8a699", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7fd12fa5efa644aea9442d66ce3f84c6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9b72a47cf16e4506b534639c3a51f41a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "712232f4d86141ddba65ab0aaa76371d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5126887f54bb4b6685de3c7330cae40f", + "Value": { + "$ID": "1e62712e4b004d97be70966381be6cb6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7b9f6afd8bbb4f37a8a7ae23e2ec84d7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "876dc39bc17448bb871802c41d8659e0", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b1aba17d3aa646a683bb29760b954641", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a6bc7768d1884abdb25dbd24949c8240", + "Value": { + "$ID": "351ce20dead048bcacb1043a6538dff0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "87699400e8194302bc7f39ec304a3b15", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "27728cd05caf48ad9d799686c6d57caf", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "824e54b164004f4b9679a3a9f2627efa", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5f8a0de7b3c44063b9e1a4457ca43258", + "Value": { + "$ID": "7528ed2d77244e6d8a5f55ab45e637d6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a75653f7014e49c695f57454f050ff9a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "25be1209611741068dcf285cf25ac33e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "27b276c493874c1694ededc49f24c90b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "0e2e3ab3467841f29358151494ac141f", + "Value": { + "$ID": "6d3a25d0244645d097460466ab89aed0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8005024a7b614ac5a35713c13c4ebcf7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "onclick", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d66cf0302d7c48bd8ef0fe7349242d24", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9dce354af2a44c389e07b79f7a996fd0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1128b00a0be3410e9e720591fa650a25", + "Value": { + "$ID": "ace1ab7ae5aa4a23bd0d8d6085335575", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "da035eb3d8234cb49e03b734827b8fe8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "onHoverLeave", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cb1235ad2c6645c6ab58b9cdb331a08b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9fe4b2b0ff474988bdbdb4e3e56f95f3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2e0ec8383923421786ecdfe348b6c037", + "Value": { + "$ID": "b25532ae028946beb70f19df3f7dcf3e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d09ce8b62c7b40d99769a7ba70120c46", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "bottom", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f0ba32b0b7564d718b5feb2de7d17cf6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "008de3a462ef47ff969be21f45e032c6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "0947f24837dc4955b353f50e1fed2fb9", + "Value": { + "$ID": "7e6576a1ad5c409aa4911ece1c75a5a4", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0d825db5820444df8fddbda6c6d50281", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "absolute", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fa7fb44f25cc4eb6be1d01314ca26d0d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9798754de1044ca0b3597489179aabc5", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6ad862c454614a41abf53d83a0ff9717", + "Value": { + "$ID": "d866d0accb3548f4b46adec8432d1150", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c62db20c11ca4d4bb4377a0384307f98", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "71b85f07db4043fe857276118603b90f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "cf31d21ff453452cb5631effe3a9c05f" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/progressbar.json b/modelsdk/widgets/templates/mendix-11.6/progressbar.json new file mode 100644 index 00000000..f73576db --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/progressbar.json @@ -0,0 +1,1441 @@ +{ + "widgetId": "com.mendix.widget.custom.progressbar.ProgressBar", + "name": "Progress Bar", + "version": "11.6.4", + "extractedFrom": "e4145eec-a60f-480d-a9be-f0635326cdce", + "type": { + "$ID": "944e6c9f7c1b4232bda7626b13f3306c", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/progress-bar", + "ObjectType": { + "$ID": "fde990a9f86b455292414b0840af5129", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "1e514eb4fa604332895d4dd71c695092", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Type", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "type", + "ValueType": { + "$ID": "41ccccd2636d45f1a42f1cfe21015f57", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "static", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "7a334344dec940949a824dbf66f8aa77", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "static", + "Caption": "Static" + }, + { + "$ID": "3bf8cc062efe46b5a746a59d2239b47e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Dynamic" + }, + { + "$ID": "e22c6a9851a64bc7be7be65a64b51964", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "2de0351bceb54d0ea5cb543b7f5b1ae2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Current value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticCurrentValue", + "ValueType": { + "$ID": "f0c8322957174e2ca1991e0df3485b84", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "50", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "6363b735ff5840e087baa1ccdb340841", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Current value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicCurrentValue", + "ValueType": { + "$ID": "c318c47b274d47eba1894a4ce11ccdd5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Decimal", + "Integer", + "Long" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "ad3ea7c1b5854a41bc05f9872e4e659c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Current value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "expressionCurrentValue", + "ValueType": { + "$ID": "8a1f337a6fb84022af59cf5167968555", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "9a93a4d0feae4d32b5c2f0f2b28a23e5", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "d6fb0a0e584646a499d6fb11ef590cee", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticMinValue", + "ValueType": { + "$ID": "dad03323c6f54af8a087945f76b74457", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "0", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "faa9de725689408db0ae597bccfecef1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicMinValue", + "ValueType": { + "$ID": "f848ba13e6f14dffb61f509b32be21c3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Decimal", + "Integer", + "Long" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "345748c40fd14f429fa6bbc1b8972088", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "expressionMinValue", + "ValueType": { + "$ID": "73e4e171386046ddbbe8b54e6428d903", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "d059ecdcff2c4c0c97e3dedc5b769f0e", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "483d1b946ccd435b8a0f8c9a10a747fe", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticMaxValue", + "ValueType": { + "$ID": "72e692a291df41efa31421eb6dcc62b6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "cab55d0c44854dd8a130e22d98dd4a15", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicMaxValue", + "ValueType": { + "$ID": "672c807573374a1a9f5171f0ae9508ae", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Decimal", + "Integer", + "Long" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "ddb641cc89be45bfab18cba7062eef25", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "expressionMaxValue", + "ValueType": { + "$ID": "228bd9f9aad54867bcf9fb3378a99551", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "314500999e7049e5a6dbe085ce8852a8", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "4f8b788e95e249d3bfe6fa32446c47c1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "1e5eef190ff942729f13de0f88e19265", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "ce23095f395d4fb892f363a78a7e7cd8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClick", + "ValueType": { + "$ID": "6e080a3c6f764c2e8c121d1340ddf4b0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "c81ab1d734d644e5bcf8bb632ea96400", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show label", + "Category": "Progress Label::Progress Label", + "Description": "", + "IsDefault": false, + "PropertyKey": "showLabel", + "ValueType": { + "$ID": "d4e751d4c300495f88a643879b3b278d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "42b87d6da19c4d948e1fd2c978d323f0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Label type", + "Category": "Progress Label::Progress Label", + "Description": "Note: If the Size of the progress bar is set to \"Small\" in the Appearance tab, then text and percentage labels will be shown in a tooltip and custom labels will be ignored.", + "IsDefault": false, + "PropertyKey": "labelType", + "ValueType": { + "$ID": "f7be2ef4139f402182ea8f24ec3b191f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "text", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "c184c2e47516406c87b0f0e7be2d6af5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "text", + "Caption": "Text" + }, + { + "$ID": "d9d2491650774ed7a63bed38aa5e115f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentage", + "Caption": "Percentage" + }, + { + "$ID": "455e316459904de887d5947e10bf37b7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "custom", + "Caption": "Custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "a261aa8eb6344c919992eb5129c8b909", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Label text", + "Category": "Progress Label::Progress Label", + "Description": "", + "IsDefault": false, + "PropertyKey": "labelText", + "ValueType": { + "$ID": "4970890363d4437083e63fa843c8c3f4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "c62372e449af4a299f42a2314f6af605", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom label", + "Category": "Progress Label::Progress Label", + "Description": "", + "IsDefault": false, + "PropertyKey": "customLabel", + "ValueType": { + "$ID": "f615f936bbcf4a55b62b157fc510f3da", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Display", + "StudioProCategory": "Display", + "SupportedPlatform": "Web", + "WidgetDescription": "The widget lets you display a percentage as a bar", + "WidgetId": "com.mendix.widget.custom.progressbar.ProgressBar", + "WidgetName": "Progress Bar", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "f30664b9429e479592fc180c0beab22a", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "a845fc4f36ba4c67a2c60d172b68d61d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1e514eb4fa604332895d4dd71c695092", + "Value": { + "$ID": "e21d0099b55242888ff0f665fd1da180", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "eb6cbdd94e2d4c67b3bfd980ed9cd19a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "static", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "41ccccd2636d45f1a42f1cfe21015f57", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4634df7411c74513b1ad845033d15c5d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2de0351bceb54d0ea5cb543b7f5b1ae2", + "Value": { + "$ID": "3d924c1c8c5f43c3a186a50a29723021", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "084f97f1240944b2b9cbd087ce39e748", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "50", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f0c8322957174e2ca1991e0df3485b84", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a948bcd5e1ad4bb6897c628f9174d05d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6363b735ff5840e087baa1ccdb340841", + "Value": { + "$ID": "4686251ee5db455388c01c93f8b7c63b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c97d99dae5a94d2fb74561bd87123926", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c318c47b274d47eba1894a4ce11ccdd5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "36f6d8f8019e47b882ee25e67f9847f0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ad3ea7c1b5854a41bc05f9872e4e659c", + "Value": { + "$ID": "868f7cfb76a945e6befc7273d46e9b1b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ad731613d3a14f46a823a8c9430908ce", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8a1f337a6fb84022af59cf5167968555", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d9543361c1e441b299eecbaa05887be8", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d6fb0a0e584646a499d6fb11ef590cee", + "Value": { + "$ID": "c21b2dd69c214378928baeb90a433e2b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "188ab117006d438588fb7c4faedb199f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "0", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "dad03323c6f54af8a087945f76b74457", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "42cdc990cb644055962a0b166e7c081d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "faa9de725689408db0ae597bccfecef1", + "Value": { + "$ID": "a3f41185563243ff86bf49b2a0675064", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5ceb2ab6b7e148269f44e6fceb382154", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f848ba13e6f14dffb61f509b32be21c3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "66be0df376aa43c3b5cab6ff0807e9fb", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "345748c40fd14f429fa6bbc1b8972088", + "Value": { + "$ID": "4c3c60eb4305434d90221e27d7accc43", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e2eece22a5f64cef9a4ee25897e18d52", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "73e4e171386046ddbbe8b54e6428d903", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b04668346cff4edb8aabca81600a0f74", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "483d1b946ccd435b8a0f8c9a10a747fe", + "Value": { + "$ID": "14f64efbbf4343b8bc42038f534b3a20", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f9ee5e966aa844639b7b80bff72a4f61", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "72e692a291df41efa31421eb6dcc62b6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ffaf286e3e5a4b25ac5b2ff1dc3a8c07", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cab55d0c44854dd8a130e22d98dd4a15", + "Value": { + "$ID": "d6244bca034c4ebf926926d2f999afc1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "25a6bcaf3af344c58091fbd4393ba69d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "672c807573374a1a9f5171f0ae9508ae", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "7a5c656dd02d4921b4e30a4e9ec0baf6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ddb641cc89be45bfab18cba7062eef25", + "Value": { + "$ID": "ccfb935783e04033b33b4abb07d9979c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "54e559686d104059803e2704662c6760", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "228bd9f9aad54867bcf9fb3378a99551", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1cf8ce170a3d4ce085c031887bfee7e9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ce23095f395d4fb892f363a78a7e7cd8", + "Value": { + "$ID": "ab88d9b40cd84edb834e782d815bd599", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b6043e5b826a4b70a9f70631697bcee3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6e080a3c6f764c2e8c121d1340ddf4b0", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "0edd152f744a4f21ab4a1714e551d4fd", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c81ab1d734d644e5bcf8bb632ea96400", + "Value": { + "$ID": "563eaa30d77b4060adfcc21d3ab561c6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c1d4cd8d21ae43ffa5e7f6c688a5d58b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d4e751d4c300495f88a643879b3b278d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6a8448fe207343f09aa3ec3073ff6a49", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "42b87d6da19c4d948e1fd2c978d323f0", + "Value": { + "$ID": "2293a78248864e8fbe2b282ef4838536", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b563093f08b24565ab3a3f445b880bb5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "text", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f7be2ef4139f402182ea8f24ec3b191f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d6f9c1ac07fe4df584d2486c89bf89a3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a261aa8eb6344c919992eb5129c8b909", + "Value": { + "$ID": "3295fe4bc1b64e9092bba87e40edd8bd", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "56983ceafb234e73bf33a404ad7949be", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4970890363d4437083e63fa843c8c3f4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4848119a2cec4381b11fa6d6543303b0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c62372e449af4a299f42a2314f6af605", + "Value": { + "$ID": "b0ac100698654fcebc7f2b37c5d9f94a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8677d0af9129466899b92796b8269284", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f615f936bbcf4a55b62b157fc510f3da", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "fde990a9f86b455292414b0840af5129" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/progresscircle.json b/modelsdk/widgets/templates/mendix-11.6/progresscircle.json new file mode 100644 index 00000000..e59d5d2a --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/progresscircle.json @@ -0,0 +1,1441 @@ +{ + "widgetId": "com.mendix.widget.custom.progresscircle.ProgressCircle", + "name": "Progress circle", + "version": "11.6.4", + "extractedFrom": "14dbd39d-2ed6-41f0-97ab-0b8a7927de64", + "type": { + "$ID": "2eb90fcac5c2425294682f0d7e2484b2", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/progress-circle", + "ObjectType": { + "$ID": "ebbdb95e1b4c4c6fa9542519a449c1de", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "2ab3738ee661452186a42b3383f3ddc1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Type", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "type", + "ValueType": { + "$ID": "107b076be8f2482dbd15cf7788e2605f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "static", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "cf86fdb5d35641fa819c56c47243b325", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "static", + "Caption": "Static" + }, + { + "$ID": "f25b53b19d364b788eeb054b4c2536dc", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Dynamic" + }, + { + "$ID": "9a7569215f794457944b70c385005045", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "2c36c7fca55d40b38efd9aa8eab7bdec", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Current value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticCurrentValue", + "ValueType": { + "$ID": "e82cf05f3305400c826705a9d3fd4e9c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "50", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "40a381b5d4bc475f8c2d84b891bba1d5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Current value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicCurrentValue", + "ValueType": { + "$ID": "f43952dd54d043779993b1b7291eeb50", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Decimal", + "Integer", + "Long" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "cb5acbb1c8a04f2c8be67cbc3aeb262b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Current value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "expressionCurrentValue", + "ValueType": { + "$ID": "e08d4b98d9b84b56ab51315d6ae217e4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "1d0d60436dd34508a64c3e58b98f5414", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "e4240e167e9d4a10bc156109bbf15b90", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticMinValue", + "ValueType": { + "$ID": "25ae8dda5aa746eabfb5762a4cc02c00", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "0", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "e0cfc04b97bc42d9ba4d437a0b0cfc84", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicMinValue", + "ValueType": { + "$ID": "deb7d9b5c4f94207a896f062ca61833a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Decimal", + "Integer", + "Long" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "99f279020bb14510bf51667ad9cc3781", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "expressionMinValue", + "ValueType": { + "$ID": "cb0efd2f3475449fac18a2667c3b253f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "08505b17b3bc4df5b1c3f9366cd6ef7f", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "d20a8472d5734d3fa292bfbfd23d6fb2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticMaxValue", + "ValueType": { + "$ID": "06616c9d49cc48198026f1a4800f2a0a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "3d554ef63e76405da46e6288bf4b7fdf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "dynamicMaxValue", + "ValueType": { + "$ID": "4dea4f2bb87d4e15a962ddd5a273aafe", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Decimal", + "Integer", + "Long" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "d3d78addd4b14cfda7192abd6ce3f31b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "expressionMaxValue", + "ValueType": { + "$ID": "a152e3a0a4ab4cee96138084db2c1dbc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "6beb265e206748b1b1c663d71c052a7e", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "7093dd83e5424b1493d3cd0a2914be56", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "81e1746433674dcda8e285cc1d71fc3a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "83682c422de64ae0a2abcfeeef83b52e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click", + "Category": "General::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClick", + "ValueType": { + "$ID": "0c2b78a5e5714c7d88074fb08f3af4c7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "e90a48a2241344ffb0fff5a058a24015", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show label", + "Category": "Progress Label::Progress Label", + "Description": "", + "IsDefault": false, + "PropertyKey": "showLabel", + "ValueType": { + "$ID": "1f7af91ae1ce4295ad14f9fb71baf47d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "fc3e1c06e2b246d2a724895c91ce1a6a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Label type", + "Category": "Progress Label::Progress Label", + "Description": "", + "IsDefault": false, + "PropertyKey": "labelType", + "ValueType": { + "$ID": "40686d0058af4743a1a40b293238a743", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "text", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "95dfc73dfff34fd783fde789efb41685", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "text", + "Caption": "Text" + }, + { + "$ID": "79e2afefde984a74bd633c959552dbac", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentage", + "Caption": "Percentage" + }, + { + "$ID": "db67623a299d4da9a2f1c6b38b6a1ec5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "custom", + "Caption": "Custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "ebc6572423304b53b0eccca9d7a2f2d2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Label text", + "Category": "Progress Label::Progress Label", + "Description": "", + "IsDefault": false, + "PropertyKey": "labelText", + "ValueType": { + "$ID": "3686d1d3154042e6a6b5bfdc3967733c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "1ab4a2b500dd4fa8a6eef6362f14327a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom label", + "Category": "Progress Label::Progress Label", + "Description": "", + "IsDefault": false, + "PropertyKey": "customLabel", + "ValueType": { + "$ID": "006de2c006b44259b09ae2b7830cf545", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Display", + "StudioProCategory": "Display", + "SupportedPlatform": "Web", + "WidgetDescription": "Displays a progress in a circle", + "WidgetId": "com.mendix.widget.custom.progresscircle.ProgressCircle", + "WidgetName": "Progress circle", + "WidgetNeedsEntityContext": false, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "032defcb43a34a9eac1d009b50ae918b", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "b97478495eca46b5a2cbe6f6d428e303", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2ab3738ee661452186a42b3383f3ddc1", + "Value": { + "$ID": "62606c0886b0457ebf34228aa0f5dce3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "46979eeb5d36430ea99d309f94214695", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "static", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "107b076be8f2482dbd15cf7788e2605f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a3aa841cbb5c4d1da8aae6b3095bba8e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2c36c7fca55d40b38efd9aa8eab7bdec", + "Value": { + "$ID": "5559cce94a1d4a199d7e444a5d8fd862", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e97823a72e1146088e187217891241e3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "50", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e82cf05f3305400c826705a9d3fd4e9c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "24577a50b26a479e8d1f0c1308aa3669", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "40a381b5d4bc475f8c2d84b891bba1d5", + "Value": { + "$ID": "6bdf99b5c3d84cef811f49d0c0008592", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b616794d8b3e445fa5dad233c7274525", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f43952dd54d043779993b1b7291eeb50", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "963a477dddd044b09eb8c73ee71737c9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cb5acbb1c8a04f2c8be67cbc3aeb262b", + "Value": { + "$ID": "dd25496562024f07a455791d59840fdb", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "17759c04fdf84b81af03b9259c180d8d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e08d4b98d9b84b56ab51315d6ae217e4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "81027da277744d3fade60d08c6ce6658", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e4240e167e9d4a10bc156109bbf15b90", + "Value": { + "$ID": "cd08030a59b942a3b4b97b3d267a4987", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e28efafc74a5486893e150c230d126f9", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "0", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "25ae8dda5aa746eabfb5762a4cc02c00", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b471c2eb9af84e74b14518579c4b947d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e0cfc04b97bc42d9ba4d437a0b0cfc84", + "Value": { + "$ID": "17e4fae352204d51a838bf906dfc9165", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b7fa4ecea3034e52b9262303fd5d09cc", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "deb7d9b5c4f94207a896f062ca61833a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cfe7a8899d274918b821bfa76496b415", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "99f279020bb14510bf51667ad9cc3781", + "Value": { + "$ID": "18b0618550e74489a7719ba340b1c99b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5266500fd2e04f318819f7ee2531e695", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cb0efd2f3475449fac18a2667c3b253f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "92fed44e35194b34aa3131638e72ba64", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d20a8472d5734d3fa292bfbfd23d6fb2", + "Value": { + "$ID": "83616bcf1c6144f38cfb7d538bc056de", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "60e19e5cec5a43b6a3165401e9716fb5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "06616c9d49cc48198026f1a4800f2a0a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5db59a13ae3e49b3ab48828ca276cfa6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3d554ef63e76405da46e6288bf4b7fdf", + "Value": { + "$ID": "7a33e458b587491bb553dd8b715411e2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1b547aff8bc14d8b94480ceffaea6e0f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4dea4f2bb87d4e15a962ddd5a273aafe", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ffd1030fec60496183234a9f5786c6a7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d3d78addd4b14cfda7192abd6ce3f31b", + "Value": { + "$ID": "6a1ecb96bec947b99948558ddf9051b3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "385c5e7337354655b7f0f716b10e270d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a152e3a0a4ab4cee96138084db2c1dbc", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d7a526b3f02c465aa4e2fce2c92c3913", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "83682c422de64ae0a2abcfeeef83b52e", + "Value": { + "$ID": "1ef5eef2eca24dc5a243de909357d104", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "789d4e8034ec4647b8b8c4647249b13b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0c2b78a5e5714c7d88074fb08f3af4c7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "614a3b8835bc465ba01fd3c70aa1ba85", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e90a48a2241344ffb0fff5a058a24015", + "Value": { + "$ID": "9c8407244b144208b39439fac4da07b3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ca038866d1a1421ea9ec2c7ed9e9e32e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1f7af91ae1ce4295ad14f9fb71baf47d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "68dfce8f5bfa42f38c8ce3cc576d9c93", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "fc3e1c06e2b246d2a724895c91ce1a6a", + "Value": { + "$ID": "68730fb666fd440ea2a86f5e55d3e423", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2cf70ca00db74cf68510ee53b50db2e9", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "text", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "40686d0058af4743a1a40b293238a743", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ce4f9fb3683542829a737bd737e942c4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ebc6572423304b53b0eccca9d7a2f2d2", + "Value": { + "$ID": "027f403fd9774ffdbebc210157d24da2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "961bc1fbff134ee8a20c510187a276d7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "3686d1d3154042e6a6b5bfdc3967733c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "20cad138eeff43959ccb203cd1f00b17", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1ab4a2b500dd4fa8a6eef6362f14327a", + "Value": { + "$ID": "be7a951a8e7141028a6a51d13f560aec", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b3fb327b068e424488152a148354178d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "006de2c006b44259b09ae2b7830cf545", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "ebbdb95e1b4c4c6fa9542519a449c1de" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/rangeslider.json b/modelsdk/widgets/templates/mendix-11.6/rangeslider.json new file mode 100644 index 00000000..27f10f5b --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/rangeslider.json @@ -0,0 +1,2645 @@ +{ + "widgetId": "com.mendix.widget.custom.RangeSlider.RangeSlider", + "name": "Range Slider", + "version": "11.6.4", + "extractedFrom": "4a968512-f88c-4148-9b0c-3e0c361ff04d", + "type": { + "$ID": "3ef28a01fc1f477382c8582336cb3153", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "", + "ObjectType": { + "$ID": "e2cc58fe74c94d28810bb7fb24561cc7", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "554ec4315ec245929352273932a89c3b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Lower bound attribute", + "Category": "General::Data source", + "Description": "The lower bound value on the slider", + "IsDefault": false, + "PropertyKey": "lowerBoundAttribute", + "ValueType": { + "$ID": "7ddfe9e2ed994fb693846b05486ec390", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Integer", + "Long", + "Decimal" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "4d40c949191f48a7be90a0b0d68b6196", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Upper bound attribute", + "Category": "General::Data source", + "Description": "The upper bound value on the slider", + "IsDefault": false, + "PropertyKey": "upperBoundAttribute", + "ValueType": { + "$ID": "3ab0df4ea43a4605b5cc39442711eeed", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Integer", + "Long", + "Decimal" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "5c85326a4d40481280a9d404528e0144", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Enable advanced options", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "advanced", + "ValueType": { + "$ID": "92d6938916c54fd082e893e22d92427d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "46ba53f1c6a7432a95bb0ce57a758689", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value type", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "minValueType", + "ValueType": { + "$ID": "3729aacdb4b74941a0957e01ef511017", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "static", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "01ccadea284d4a10a80efc8c3b583d61", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "static", + "Caption": "Static" + }, + { + "$ID": "96111ba405384d6c9ffd081870d1e8f4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Dynamic" + }, + { + "$ID": "0ed866f9d5654e62afc6c81c0127e8ca", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "b02238afde6f49809a91ce4f8bea0d06", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticMinimumValue", + "ValueType": { + "$ID": "b6fab1e61b5a4bb597862f0b28d2c627", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "0", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Decimal" + } + }, + { + "$ID": "68645c7548e54db2a680f8c3d0e29ced", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "minAttribute", + "ValueType": { + "$ID": "a3eb0a7c01b34349b96e5cdcd527b79e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Decimal", + "Integer", + "Long" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "4424aa30958c4855bfbeb28c4b3454e1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "expressionMinimumValue", + "ValueType": { + "$ID": "ddc8d32eb1e34a0a9ae024f2301027ea", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "4aa1c645a2f14a4aba2e55baac3c8325", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "6f5e9fa2c60045bea9897d4f243bf73c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value type", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "maxValueType", + "ValueType": { + "$ID": "4b5ae9fe42f547b88ebcbe0bb93eaaec", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "static", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "345d7212c0a647e08d88fc00b8778ac9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "static", + "Caption": "Static" + }, + { + "$ID": "b1e9067977904a53b3df83388faad3ad", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Dynamic" + }, + { + "$ID": "9078792f7b82482597105887d6818867", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "e325d43051d64b0b8447c57f15161fd5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "staticMaximumValue", + "ValueType": { + "$ID": "85adc388c8424978ac39a965f38cbb6b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Decimal" + } + }, + { + "$ID": "5142730aa3a141f79cebc2bb5d4b3bc3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "maxAttribute", + "ValueType": { + "$ID": "9959994b157d4623a631f024bee24833", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Integer", + "Long", + "Decimal" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "1e6ad7c767944c3582e9a2191e98f386", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "expressionMaximumValue", + "ValueType": { + "$ID": "65f20d1ed81d46dc8e0e6bd7bf0767c8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "9ea5f5100415436b9193d4b548c563b8", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "330fef525af74d639eba268a60365db5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Step size type", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "stepSizeType", + "ValueType": { + "$ID": "98af97293fce479690fbcf69f8eb07e2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "static", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "d01d092b3c1b4766943e984b59939b93", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "static", + "Caption": "Static" + }, + { + "$ID": "fa391f6df22c4d0e852fc05b4ec1cc14", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Dynamic" + }, + { + "$ID": "002b53450d574455a17c9a266de74178", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "c896c97f7f8a44a3ad17a233ac90eb21", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Step size", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "stepValue", + "ValueType": { + "$ID": "7eef723e9a144b0cbf7592ec39d40038", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "1", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Decimal" + } + }, + { + "$ID": "9b62bdaa50f343c89d72ee615e78e554", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Step size", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "stepAttribute", + "ValueType": { + "$ID": "fb6506d8ebd241669b78ede1bf270f90", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Integer", + "Long", + "Decimal" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "fd0f5896d6794d99bbf2d2df9f85ba3e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Step size", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "expressionStepSize", + "ValueType": { + "$ID": "cf476108aaf14ea9b97d4069d5ea6347", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "d6efca05384a422e9c920812354577a7", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "0a4b77100f5d45e1b64de00d9146f0a0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show tooltip", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "showTooltip", + "ValueType": { + "$ID": "c7d47ea71e714d6896b5ad7e78495a79", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "c5cf364875e2467cb7a7e0073be07115", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Lower bound tooltip type", + "Category": "General::General", + "Description": "By default tooltip shows current value. Choose 'Custom' to create your own template.", + "IsDefault": false, + "PropertyKey": "tooltipTypeLower", + "ValueType": { + "$ID": "ca53df30de394047ab012bf02941f3cd", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "value", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "ecf36d6cde1143759b2e1ff629535f1f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "value", + "Caption": "Value" + }, + { + "$ID": "138ae2ff5e3e45d1858a0e8f91ea63dc", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "customText", + "Caption": "Custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "b344c50078e345de8e50905065d3a18f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "tooltipLower", + "ValueType": { + "$ID": "4ec00d853dac490fb586ae481424ef2a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "010da53cbf424383892220994429816d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Upper bound tooltip type", + "Category": "General::General", + "Description": "By default tooltip shows current value. Choose 'Custom' to create your own template.", + "IsDefault": false, + "PropertyKey": "tooltipTypeUpper", + "ValueType": { + "$ID": "259e78212ad54c22a9e1d802674886ad", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "value", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "fe7b60a2326848c5a5f11840f8e2306a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "value", + "Caption": "Value" + }, + { + "$ID": "81b90f6248734f188b1bead66a5707ef", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "customText", + "Caption": "Custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "310c51d35fa1485baff199a21fa2e8a2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "tooltipUpper", + "ValueType": { + "$ID": "cc0c047bd9e643828eea559a2455108f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "83fe76da909e4bb4bb6228d11013965a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip always visible", + "Category": "General::General", + "Description": "When enabled tooltip is always visible to the user", + "IsDefault": false, + "PropertyKey": "tooltipAlwaysVisible", + "ValueType": { + "$ID": "26aa062192c4436ba64028ee21bb248f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "ab13e877cd3049a5baf80bd37b0d40f6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "Label", + "ValueType": { + "$ID": "934bde1943514ba584bd86fab1a68f1e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "c34733b7ec8340f2bea61806306cb684", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Editability", + "Description": "", + "IsDefault": false, + "PropertyKey": "Editability", + "ValueType": { + "$ID": "a8ccd4935b2c4a50a96e98b4797be4f2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "8a5acda206704d0a88e118aa6136ec8e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Visibility", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "3695694c4da64fee9b9d6ceec1830533", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "2911689cb2644e4d9fe8c47841e25572", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Number of markers", + "Category": "Track::Track", + "Description": "Marker ticks on the slider (visible when larger than 0)", + "IsDefault": false, + "PropertyKey": "noOfMarkers", + "ValueType": { + "$ID": "c205f26b4dc64ad7bf8e8155aef8b3dd", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "1", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "cd8a414fb6614e8885c56023a8d3f11a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Decimal places", + "Category": "Track::Track", + "Description": "Number of decimal places for marker values", + "IsDefault": false, + "PropertyKey": "decimalPlaces", + "ValueType": { + "$ID": "4ccbe005f0824547bc74ebabe9845679", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "0", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "2b283254046d48888e2a7c02d631c53e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Orientation", + "Category": "Track::Track", + "Description": "If orientation is 'Vertical', make sure that parent or slider itself has fixed height", + "IsDefault": false, + "PropertyKey": "orientation", + "ValueType": { + "$ID": "59f8eb1b03c1485ca4f16d2df33ef36c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "horizontal", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "49bb78f43d484d27a2913f293bd347a1", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "horizontal", + "Caption": "Horizontal" + }, + { + "$ID": "ba5c432291304e7b900cde060fa63867", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "vertical", + "Caption": "Vertical" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "ec281d6e770345f58940cff2c3f3ed3e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height unit", + "Category": "Track::Track", + "Description": "", + "IsDefault": false, + "PropertyKey": "heightUnit", + "ValueType": { + "$ID": "36216cf348b2421eb1ca3f2c33c98ced", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "percentage", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "dcfacae9da2444ffb0e715bfd582a2ae", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentage", + "Caption": "Percentage" + }, + { + "$ID": "9db20e1253034859bbe4c9d9c20ed52d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "pixels", + "Caption": "Pixels" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "a92660eee3fb4a1f8b2a01ccf688af09", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height", + "Category": "Track::Track", + "Description": "", + "IsDefault": false, + "PropertyKey": "height", + "ValueType": { + "$ID": "891f6ffc4117404f8df4030a8ccedbc1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "1a4be49805e947fb9680d235c64612b4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "Events::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onChange", + "ValueType": { + "$ID": "632fbcaa462c46aba07e72d59606d7db", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Input Elements", + "StudioProCategory": "Input elements", + "SupportedPlatform": "Web", + "WidgetDescription": "Change range of values using a slider", + "WidgetId": "com.mendix.widget.custom.RangeSlider.RangeSlider", + "WidgetName": "Range Slider", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "cbba65d11c004925adcde3c1acb5d5db", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "1acb43e2c08440929185f890b8eb3e08", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "554ec4315ec245929352273932a89c3b", + "Value": { + "$ID": "903e8d3f7fc04ae499a51f87a89c136d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "03eea4e382934f9181c6c9a2fcdf687b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7ddfe9e2ed994fb693846b05486ec390", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "3422dd808ef941f9a78a03bf2d6643fc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4d40c949191f48a7be90a0b0d68b6196", + "Value": { + "$ID": "3cdeb75ba22a4db2a105393d9e03c396", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "51a4d7f8825747de907366ba77183fe4", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "3ab0df4ea43a4605b5cc39442711eeed", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6a33bbe8f678415a9f2dc56014405c72", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5c85326a4d40481280a9d404528e0144", + "Value": { + "$ID": "07ac1d9ff59e4ea3bb75eba45c26207c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "534c0c16b1494bf18e67b66d4130afbc", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "92d6938916c54fd082e893e22d92427d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bc9a3fbbacaa4422bdbcf1cb466c2bc0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "46ba53f1c6a7432a95bb0ce57a758689", + "Value": { + "$ID": "e0c56940e31246998215be432de34241", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8422e8193c124e02b6870552b4a1c28c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "static", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "3729aacdb4b74941a0957e01ef511017", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2ab0b61329124c35b625c0782e325018", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b02238afde6f49809a91ce4f8bea0d06", + "Value": { + "$ID": "359aff5887794a699c5d6f96eb564aaf", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c77fc70ee23c45078ae77c59d243205f", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "0", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b6fab1e61b5a4bb597862f0b28d2c627", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2fdc5e5e944d4ce1bd491564ff6b59f6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "68645c7548e54db2a680f8c3d0e29ced", + "Value": { + "$ID": "24f76d54221145968e8695c6a05ab961", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e8a1aa5a669d408ebc03420b9d4d9477", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a3eb0a7c01b34349b96e5cdcd527b79e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4008a4a554764c7592012f144be25ae7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4424aa30958c4855bfbeb28c4b3454e1", + "Value": { + "$ID": "9aef5763f13c413982ca9ca7f7575f74", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "cc793f9985ae4d0bba7247371670c7df", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ddc8d32eb1e34a0a9ae024f2301027ea", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b0fad1f32c7249ff9e92731e925b8f8e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6f5e9fa2c60045bea9897d4f243bf73c", + "Value": { + "$ID": "dc0352553bcb45afa94140c0922d85a8", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "db7151c34c7e4131bf29710d8c2ccf0c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "static", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4b5ae9fe42f547b88ebcbe0bb93eaaec", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ba692c647f62483aa871ac06b427f9a2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e325d43051d64b0b8447c57f15161fd5", + "Value": { + "$ID": "7b4a9936bcc74628919729cb40b66475", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "10c83c0011654652ad66052ebea94c10", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "85adc388c8424978ac39a965f38cbb6b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f1e478413d7e43f7b707a3e5fdb26ff6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5142730aa3a141f79cebc2bb5d4b3bc3", + "Value": { + "$ID": "131d35c69e9c4a9fa05732220e45d549", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0af7838f2b144d91b2e67a18ca5a74eb", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9959994b157d4623a631f024bee24833", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b48dd8a49ab64a2c8b7b1cd49c60dad6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1e6ad7c767944c3582e9a2191e98f386", + "Value": { + "$ID": "b7b0e3d2609a4c6d82b84051b3ee55b4", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6857e33ba09240eca9e870fe0e145984", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "65f20d1ed81d46dc8e0e6bd7bf0767c8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c07f1781e79140849cb1ee304fc5a7d1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "330fef525af74d639eba268a60365db5", + "Value": { + "$ID": "36876299f2cf46dc9bd1a45468714d1a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "20eb87a0e3b94d2090fa4f08ed096dc7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "static", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "98af97293fce479690fbcf69f8eb07e2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "92344fdd38e7477dbb1e82ccde8494fc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c896c97f7f8a44a3ad17a233ac90eb21", + "Value": { + "$ID": "a79276a77b294ea4b1ad58e6fbc5bc60", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b3c1a5a5a5514aeba25978f0e9014895", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "1", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7eef723e9a144b0cbf7592ec39d40038", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "fe9ae3e344724a4aad0747b509d2ebfa", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9b62bdaa50f343c89d72ee615e78e554", + "Value": { + "$ID": "87e2f3f1efde40d48f37e07e66952593", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3266b720fbf846a1beda336e26836f03", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fb6506d8ebd241669b78ede1bf270f90", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "7c908ca175e14c239259b47b1de90c85", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "fd0f5896d6794d99bbf2d2df9f85ba3e", + "Value": { + "$ID": "a61ca865c0ac45fc90473d078305058e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "04458b8a97fb48f2ab0e7d35e870acc0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cf476108aaf14ea9b97d4069d5ea6347", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a1027c63ad074f0d8e8a99c8066aaa03", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "0a4b77100f5d45e1b64de00d9146f0a0", + "Value": { + "$ID": "0bd7b2359a584b3a90e2404a43694e16", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "63f8724be78a4a339c5f78093b577842", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c7d47ea71e714d6896b5ad7e78495a79", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5d61331e6e854b73b094e2f0a46fec5e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c5cf364875e2467cb7a7e0073be07115", + "Value": { + "$ID": "643315a84bf4451b98dd1bfdb01c1676", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "00fbe50e19f24c6ebd8789c7358b4006", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "value", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ca53df30de394047ab012bf02941f3cd", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "782b04fb61234c03ab25f365e11fefd8", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b344c50078e345de8e50905065d3a18f", + "Value": { + "$ID": "84552986c0334d6f92ef66f9ec0f0b2b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e0770e0615a440658ed948d98efbe105", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4ec00d853dac490fb586ae481424ef2a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5303c529bb7249e4aed69e783f0bfb88", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "010da53cbf424383892220994429816d", + "Value": { + "$ID": "77e81d0f386c41e7893fc248078c95c6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "56e8b845ff2f4bf196775a3ecbeaaa4d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "value", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "259e78212ad54c22a9e1d802674886ad", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "72dc2c902b894f89abe0461db79995ec", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "310c51d35fa1485baff199a21fa2e8a2", + "Value": { + "$ID": "665dd01061b445a6a13c0f525f72b8d7", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b63cfbc784c9433c9688dfe840975c40", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "cc0c047bd9e643828eea559a2455108f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "47c108b8197341d79ebe2d1ced21c556", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "83fe76da909e4bb4bb6228d11013965a", + "Value": { + "$ID": "880a501ef2794437bbb9e96f31a7de92", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1ec7d121a7654de3ad50b46ff6cf6868", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "26aa062192c4436ba64028ee21bb248f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a26c364d0a3d4e6bbb6b3fc83af95dd3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2911689cb2644e4d9fe8c47841e25572", + "Value": { + "$ID": "5412309138b24b95969d02a91100bf5c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "70848fc696334358bc449eedda9f7f4c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "1", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c205f26b4dc64ad7bf8e8155aef8b3dd", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e0f8f9b800a54716bd377c93a6d42f79", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cd8a414fb6614e8885c56023a8d3f11a", + "Value": { + "$ID": "ee73be96e4ae49fc9a15dd85fc3ac5cd", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "89ef6bc26a824f339f70818bbeaa5a1a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "0", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4ccbe005f0824547bc74ebabe9845679", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "31def9ab3f4947b0abc7b48685919096", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2b283254046d48888e2a7c02d631c53e", + "Value": { + "$ID": "765ebef6f23444a79b216dd56dd104d6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e6d2290b2d4648e6b8a7c70a63df9768", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "horizontal", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "59f8eb1b03c1485ca4f16d2df33ef36c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a2d27a81574240ba9d3d9c737ce77334", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ec281d6e770345f58940cff2c3f3ed3e", + "Value": { + "$ID": "e81e0bad32e44d8fa97851862e7fa8e7", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1f8b95accb8248adbd6bfff1416b0a40", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "percentage", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "36216cf348b2421eb1ca3f2c33c98ced", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f24db2bd41d542e9a35d2a23b33d940a", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a92660eee3fb4a1f8b2a01ccf688af09", + "Value": { + "$ID": "4298ce03ea3d47e19337f6f0da7beb2c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "346ed2285f0340b5867a2b9c105ee978", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "891f6ffc4117404f8df4030a8ccedbc1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c70de5699ba342e9a8a295bc4a93f84e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1a4be49805e947fb9680d235c64612b4", + "Value": { + "$ID": "b415cdda945b4f2b979b6b9a3a798e05", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "57ccfa31b4a44d9e86cc28970f3089f6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "632fbcaa462c46aba07e72d59606d7db", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "e2cc58fe74c94d28810bb7fb24561cc7" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/selectionhelper.json b/modelsdk/widgets/templates/mendix-11.6/selectionhelper.json new file mode 100644 index 00000000..90b4551a --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/selectionhelper.json @@ -0,0 +1,497 @@ +{ + "widgetId": "com.mendix.widget.web.selectionhelper.SelectionHelper", + "name": "Selection helper", + "version": "11.6.4", + "extractedFrom": "db6308e9-1668-4b9c-9362-396926b9be58", + "type": { + "$ID": "873c092cebf748da851343a09e88f45b", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/modules/gallery#selection-helper-widget", + "ObjectType": { + "$ID": "9e656c653ef342d3845454289b322274", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "4037e1c6c68d4e73b05b9b3a867426f9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Style", + "Category": "General", + "Description": "Custom enables placeholders for using widgets for the different states.", + "IsDefault": false, + "PropertyKey": "renderStyle", + "ValueType": { + "$ID": "d48a6b57e84742f2a9bb6ceb0aeafe25", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "checkbox", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "7ad644c4c05a46fe81fee3a832ea2d44", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "checkbox", + "Caption": "Check box" + }, + { + "$ID": "6579c8c4b06447daa247638b6ee5927c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "custom", + "Caption": "Custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "d7829790916f40aca6ef134f9edf0766", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Check box caption", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "checkboxCaption", + "ValueType": { + "$ID": "149877eae02848e9aa3d2ba6a1e6ef7f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "9649f6f5faae43b69ac24086fd9ce1d1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "All selected", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "customAllSelected", + "ValueType": { + "$ID": "7fb6b2bb41024f609ba68494223d0d62", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "48e2e7c08c8f47358e3d9d12744130a3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Some selected", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "customSomeSelected", + "ValueType": { + "$ID": "fcd058c1a9834a3da831dce7d604751b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "dc0ff7d1f6944af8a0e0d81ad8852c7a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "None selected", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "customNoneSelected", + "ValueType": { + "$ID": "36652ea8325147a6bad5d74f0e4d2239", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Data Controls", + "StudioProCategory": "Data controls", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.selectionhelper.SelectionHelper", + "WidgetName": "Selection helper", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "b42d0753072a49e895ff65a182234092", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "457c864d7e754c6faa9de43665e83083", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4037e1c6c68d4e73b05b9b3a867426f9", + "Value": { + "$ID": "7b26ad31e3a641e081a751f8126d5b4a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9357181066c0428c861f8866416df4bf", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "checkbox", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d48a6b57e84742f2a9bb6ceb0aeafe25", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "5ca12cdcc96b47df82adfbec5846e4bc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d7829790916f40aca6ef134f9edf0766", + "Value": { + "$ID": "2bd7f1f1ce324c32bbbbfe9101e20800", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "41b170058a14431c853b4a769fc89e31", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "c6e21fe70f204a47a51b9a47f37f0ce5", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "a2b27af9d35c49e4aa187bd9b280ec90", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "c30b2d4e59944a54b5e655a017870541", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "149877eae02848e9aa3d2ba6a1e6ef7f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f8a490c0e07b45449d6b4e5b9f006979", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9649f6f5faae43b69ac24086fd9ce1d1", + "Value": { + "$ID": "0c0fe3f2dc1b47d5822100d6ffe81a43", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6d79b0f1557449979d73df56805538a7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7fb6b2bb41024f609ba68494223d0d62", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b1342d22e8ab4dd9b58d0ca0309d12ef", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "48e2e7c08c8f47358e3d9d12744130a3", + "Value": { + "$ID": "a4ec99c420c64b92b8236967505f76a0", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0b4161f0fedb47daa7d802ff5dbcd12b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fcd058c1a9834a3da831dce7d604751b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9b32f57d6ba8470897c2e9f30c5739cb", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "dc0ff7d1f6944af8a0e0d81ad8852c7a", + "Value": { + "$ID": "dbec3df9cc73483c9f097bb71161cb0b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c9b5c7537dcc49a9abc088527b2f5332", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "36652ea8325147a6bad5d74f0e4d2239", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "9e656c653ef342d3845454289b322274" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/slider.json b/modelsdk/widgets/templates/mendix-11.6/slider.json new file mode 100644 index 00000000..46858142 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/slider.json @@ -0,0 +1,2372 @@ +{ + "widgetId": "com.mendix.widget.custom.slider.Slider", + "name": "Slider", + "version": "11.6.4", + "extractedFrom": "4e3b4136-5eec-4dcd-8d73-a35b2780f568", + "type": { + "$ID": "1cebcd49b4784d1bb7df56ead6a23852", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "", + "ObjectType": { + "$ID": "34982dee741746dba78ec516d879e64b", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "35fef95bbdcf43889f04602705c7ef75", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Value attribute", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "valueAttribute", + "ValueType": { + "$ID": "1e349f4b57ca4073ac440aade34e5c89", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Integer", + "Long", + "Decimal" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "f810a14e29ae4150a63eae21367d7174", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Enable advanced options", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "advanced", + "ValueType": { + "$ID": "e7644006a32647089322604588c1d0d5", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "869bb41535c54405b0fbfbdb8d6e04f3", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value type", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "minValueType", + "ValueType": { + "$ID": "67eca3e1eeb5444582a56e16071d40c3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "static", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "b2874eb4b98e4b7b93f28f0bb4c7aa9b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "static", + "Caption": "Static" + }, + { + "$ID": "2f2915c85fc445848282a9140139a9fc", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Dynamic" + }, + { + "$ID": "95242983e9f948df8574278122f5e295", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "1f4751df33a8448cbfb5a15aabe65e8f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "The minimum value of the slider.", + "IsDefault": false, + "PropertyKey": "staticMinimumValue", + "ValueType": { + "$ID": "79e246b8001e4c1daf97d0b152fc4c11", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "0", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Decimal" + } + }, + { + "$ID": "afb6a44c7cbd4f1e8ec78bcd9d6fffb7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "The minimum value of the slider.", + "IsDefault": false, + "PropertyKey": "minAttribute", + "ValueType": { + "$ID": "c64e95e54d594ed691ae52336031cfc6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Decimal", + "Integer", + "Long" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "1fbc6b692e4a4ba5b4c6eb75568ce0ef", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Minimum value", + "Category": "General::General", + "Description": "The minimum value of the slider.", + "IsDefault": false, + "PropertyKey": "expressionMinimumValue", + "ValueType": { + "$ID": "a308b1ad527f475badf313456be8bf9b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "753d69b97c9944589ddda0f2d3ab43c1", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "0eff64514f594e8eb9b1f6f323f02a4c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value type", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "maxValueType", + "ValueType": { + "$ID": "0045153c59b34939accce0c12a31040c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "static", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "eca9b1b245e4437fa49ff118563b1c5f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "static", + "Caption": "Static" + }, + { + "$ID": "3773f805a57d47989394c38c312bed2e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Dynamic" + }, + { + "$ID": "30ab60bf76e248bb81e02743e216abcd", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "b035f99160b143a0b300a16db407b225", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "The maximum value of the slider.", + "IsDefault": false, + "PropertyKey": "staticMaximumValue", + "ValueType": { + "$ID": "861edef43b324c9ebd43da8db2fb8281", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Decimal" + } + }, + { + "$ID": "deccb8f618e149f89bb2196691e7c2ab", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "The maximum value of the slider.", + "IsDefault": false, + "PropertyKey": "maxAttribute", + "ValueType": { + "$ID": "fe8bbc121b2844d1977c2393cf89f06a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Integer", + "Long", + "Decimal" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "45fe495d72454e94bfa69e2e23109806", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Maximum value", + "Category": "General::General", + "Description": "The maximum value of the slider.", + "IsDefault": false, + "PropertyKey": "expressionMaximumValue", + "ValueType": { + "$ID": "3f325bb0ebbf44c680a122b9a66ad8c1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "39668ff1e1be46859fb78d7b78864e39", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "c1a8a0fb09b64c2b9a57f9f4fba8a4a4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Step size type", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "stepSizeType", + "ValueType": { + "$ID": "e7f4ca319aee4715bf46ded2d3011884", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "static", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "703ed7c25c024b27a64afcce12e563d4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "static", + "Caption": "Static" + }, + { + "$ID": "21aef542caac4d4dbc385c83720493d5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Dynamic" + }, + { + "$ID": "e879bed1e4d2471d8f4c1870644cd956", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "930d4c830ca542f7bf4ca3a59880ddb6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Step size", + "Category": "General::General", + "Description": "Value to be added or subtracted on each step the slider makes. Must be greater than zero, and max - min should be evenly divisible by the step value.", + "IsDefault": false, + "PropertyKey": "stepValue", + "ValueType": { + "$ID": "a68199998b66481aa0c729d1eb94c3c3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "1", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Decimal" + } + }, + { + "$ID": "aaad1c83d6b84ffeb6559b386d449358", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Step size", + "Category": "General::General", + "Description": "Value to be added or subtracted on each step the slider makes. Must be greater than zero, and max - min should be evenly divisible by the step value.", + "IsDefault": false, + "PropertyKey": "stepAttribute", + "ValueType": { + "$ID": "2aeb530b852d4d95874ee117141c6831", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Integer", + "Long", + "Decimal" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "ca30f6e05b1c423fb42511c8b3bd0b91", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Step size", + "Category": "General::General", + "Description": "Value to be added or subtracted on each step the slider makes. Must be greater than zero, and max - min should be evenly divisible by the step value.", + "IsDefault": false, + "PropertyKey": "expressionStepSize", + "ValueType": { + "$ID": "e31284698448401f9e2b6b4d62b3b2a4", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "0f065c4d736e4e36b9bb467772b23975", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "Decimal" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "6bb028d9aa9a44b5b5125566be472048", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show tooltip", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "showTooltip", + "ValueType": { + "$ID": "112f76408933403aaf6f156e9418f824", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "8b030048dcdf41eb8e094add6b3232a9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip type", + "Category": "General::General", + "Description": "By default tooltip shows current value. Choose 'Custom' to create your own template.", + "IsDefault": false, + "PropertyKey": "tooltipType", + "ValueType": { + "$ID": "25af66a7b26a493086c6b7bc79aa21fa", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "value", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "5b4933e5aba541e2ad0630096fbc8524", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "value", + "Caption": "Current value" + }, + { + "$ID": "4f06e8c3c7144bd0bd4dfc1a976ed40b", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "customText", + "Caption": "Custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "4f210c5eb81a4f1d8eeb295481c48998", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "tooltip", + "ValueType": { + "$ID": "2d0c63a8f90f4ab0a4a41f601b446bc9", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "df9a24f780ed4ecfb36166ef9138bd99", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip always visible", + "Category": "General::General", + "Description": "When enabled tooltip is always visible to the user", + "IsDefault": false, + "PropertyKey": "tooltipAlwaysVisible", + "ValueType": { + "$ID": "b28b5b44621b4af6a319318156f548b8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "d56d407ae65b46fba87951cbcc973491", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "Label", + "ValueType": { + "$ID": "863fdf607f264a1d826f8b899ce49705", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "05cd9b84dd044a15907c97a0a8ec8da9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Editability", + "Description": "", + "IsDefault": false, + "PropertyKey": "Editability", + "ValueType": { + "$ID": "ab0c0691fdb94a9eb0b72e913c7b64ab", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "47fd1c80e8d44122acf2b583d7805790", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Visibility", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "1c8370fd1715484f9368a39cca9228a8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "da4383b726da4ab8aa34beebc76f62cd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Number of markers", + "Category": "Track::Track", + "Description": "The number of marker ticks that appear along the slider’s track. (Visible when larger than 0)", + "IsDefault": false, + "PropertyKey": "noOfMarkers", + "ValueType": { + "$ID": "61c39e3a48e64872abaa6f4d115b5ad2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "2", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "dff2979b8a5a4ba4bf13336ddba74982", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Decimal places", + "Category": "Track::Track", + "Description": "Number of decimal places for marker values", + "IsDefault": false, + "PropertyKey": "decimalPlaces", + "ValueType": { + "$ID": "5111d996d23b46ff80e1770e0f0d3290", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "0", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "6b3127ae80c94ccba05917cc8dcbf555", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Orientation", + "Category": "Track::Track", + "Description": "The orientation of the slider. If ‘Vertical’, make sure to set the either the height of the parent or slider to a fixed height.", + "IsDefault": false, + "PropertyKey": "orientation", + "ValueType": { + "$ID": "b3f7741b046942a3ac534ae99fddcbb1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "horizontal", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "8664026291c847c0b7b7d313617c0782", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "horizontal", + "Caption": "Horizontal" + }, + { + "$ID": "23530b2ffb11426b93027e248c313901", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "vertical", + "Caption": "Vertical" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "5814b1dd87a74ded8568f0697df3ceb7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height unit", + "Category": "Track::Track", + "Description": "", + "IsDefault": false, + "PropertyKey": "heightUnit", + "ValueType": { + "$ID": "e6588cd2ddaa417eb7f42e95c3343a2c", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "percentage", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "58fc3f30ed5f4626981644232153adab", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentage", + "Caption": "Percentage" + }, + { + "$ID": "86367760b0c44d5ab71da51dfaa8b5eb", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "pixels", + "Caption": "Pixels" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "184cc73c595c4f7b800ac16f39cafd34", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height", + "Category": "Track::Track", + "Description": "", + "IsDefault": false, + "PropertyKey": "height", + "ValueType": { + "$ID": "a9d27309b2214be097dcc3d2918bba07", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "81540dfbce7147ddbbc46ddf1339e492", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "Events::Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onChange", + "ValueType": { + "$ID": "a85e2aecf2324c4eb977e878c7e4bfbf", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Input Elements", + "StudioProCategory": "Input elements", + "SupportedPlatform": "Web", + "WidgetDescription": "Change a number value using a slider", + "WidgetId": "com.mendix.widget.custom.slider.Slider", + "WidgetName": "Slider", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "174dd5cae14f4f8a88317781162d7683", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "a3f5a32b847743e78d23e54297c429d6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "35fef95bbdcf43889f04602705c7ef75", + "Value": { + "$ID": "4695c52f6653419d978b3ba27b785a9e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d2919263e1c5497dac6fbeef61e682fe", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1e349f4b57ca4073ac440aade34e5c89", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "24b630ba1c35497ea609d403077c8e11", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f810a14e29ae4150a63eae21367d7174", + "Value": { + "$ID": "6f709a93fc5a40198d355a06f50993c6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4a07ee70fa9d4de3a341bfec08df9c57", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e7644006a32647089322604588c1d0d5", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6eb7f55eeebb4f38a9d800d1b1845458", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "869bb41535c54405b0fbfbdb8d6e04f3", + "Value": { + "$ID": "6d3650ed536c4e9db7b12d9961c3c3cf", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d01458c499ab4181bbff0dc1b833bb0b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "static", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "67eca3e1eeb5444582a56e16071d40c3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6da9e17060134da6b7c3ee90c80810e1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1f4751df33a8448cbfb5a15aabe65e8f", + "Value": { + "$ID": "df9ffb1c0cac490fbb930b191dafd4a3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4a6f9154ecbf43cba70ce860c58ca9be", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "0", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "79e246b8001e4c1daf97d0b152fc4c11", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "95c2b7b524ac47d892ebe95124177b19", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "afb6a44c7cbd4f1e8ec78bcd9d6fffb7", + "Value": { + "$ID": "80f0ac5aa62c44898fb0df0da694f1c6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0f9a06ab0f0c446085b832ef5adc30c1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c64e95e54d594ed691ae52336031cfc6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ce261d3af3fe4324a370c9eee381294c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1fbc6b692e4a4ba5b4c6eb75568ce0ef", + "Value": { + "$ID": "d196c7b0cf284d3a812d274f39a6fe7b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "107ef85d6d65495b8d069e42b5935d0e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a308b1ad527f475badf313456be8bf9b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bb06196eda064ef997ab5a089b49b933", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "0eff64514f594e8eb9b1f6f323f02a4c", + "Value": { + "$ID": "cb14db00b1bc474b8896e90ec7357101", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "dcd92c15d2d945a4aaaf4b9e0be7949b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "static", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0045153c59b34939accce0c12a31040c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "56f1beebf4e049d88fbe57cf3fadf0d0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b035f99160b143a0b300a16db407b225", + "Value": { + "$ID": "bc94eb01b9e1401eb540074ea6a4e50a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "6a594b2e516e4bc79a72838e5cfd069d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "861edef43b324c9ebd43da8db2fb8281", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8e33888a8cbd4c868b0716291aa3dee4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "deccb8f618e149f89bb2196691e7c2ab", + "Value": { + "$ID": "b41a2897b43445299f1af2eac748dae4", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7105cd848dfd460d8b7e6f777f80ee02", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fe8bbc121b2844d1977c2393cf89f06a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cc5c2082f8454564b0077d276b02e87c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "45fe495d72454e94bfa69e2e23109806", + "Value": { + "$ID": "00b5f033a3794b77857481f50b83da3d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f7958d89b9cb4e5aa120468762af34bb", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "3f325bb0ebbf44c680a122b9a66ad8c1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ee6bb35c899648d6b8bec224605dcda0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c1a8a0fb09b64c2b9a57f9f4fba8a4a4", + "Value": { + "$ID": "d2f6c190f8eb4ee68c8f08e81960bd8f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "51b9b67af85c40cba4966eac97741baf", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "static", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e7f4ca319aee4715bf46ded2d3011884", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b9ab130a016444a9aed78bf4d02985b8", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "930d4c830ca542f7bf4ca3a59880ddb6", + "Value": { + "$ID": "d8eebe3b98ad4165bc369b3c8d54ee64", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7f37d9e734ee4cd7ab7c5506f51ed28b", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "1", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a68199998b66481aa0c729d1eb94c3c3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "536573fa2f1d42909fbfffecb419c4c2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "aaad1c83d6b84ffeb6559b386d449358", + "Value": { + "$ID": "47c7937fdd3d43d9a357d1ab739d381e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f4583334535042eaa7d4d1e131eac61a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2aeb530b852d4d95874ee117141c6831", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c3455db12fc74df4bdd6cd209ddd9401", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ca30f6e05b1c423fb42511c8b3bd0b91", + "Value": { + "$ID": "c863a9f476b647b7837c6656a75fec3d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "48b1d4a1d0884cefa38dffeead504485", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e31284698448401f9e2b6b4d62b3b2a4", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ba7a4590c37c44b597962fa8d1a22645", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6bb028d9aa9a44b5b5125566be472048", + "Value": { + "$ID": "e432d88898004cbe89a4ce01d77e2a93", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c2e14d49c26d4d908ce99ab031c41896", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "112f76408933403aaf6f156e9418f824", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "182e6be8a1fe4ad18edf21efc6365272", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8b030048dcdf41eb8e094add6b3232a9", + "Value": { + "$ID": "d3ad0e652cda4a58b6aaa2e70b319390", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "fa220cbd5a1b46c5bda6e3005e6313d4", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "value", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "25af66a7b26a493086c6b7bc79aa21fa", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2fb2b758a260432ea9607f5f9a178ea3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4f210c5eb81a4f1d8eeb295481c48998", + "Value": { + "$ID": "03b293652d4f44ab9c7359167312874b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "929fbaeda39b45e5acbf7a5ea4c41f91", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "2d0c63a8f90f4ab0a4a41f601b446bc9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b29c026ed4d2486cb668d0ca5103ff24", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "df9a24f780ed4ecfb36166ef9138bd99", + "Value": { + "$ID": "805345d4d6ce4a50b1504ac8f4ea4a63", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4d1f6bdc609a46a6b957d6248a5933e8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b28b5b44621b4af6a319318156f548b8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "713f5d30ad4a4d7b90a81ad3edf76dc3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "da4383b726da4ab8aa34beebc76f62cd", + "Value": { + "$ID": "78ba6db01b374ff0bb6e63d8fcbdad09", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "a4b02a40f454403097c481b316ab0764", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "2", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "61c39e3a48e64872abaa6f4d115b5ad2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f064ddbb0ec34cc9849eacd9b052bdd6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "dff2979b8a5a4ba4bf13336ddba74982", + "Value": { + "$ID": "274faa0d9f67481e944e8ad4bcec305e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "9e8d9fc8d5a54346ad9a5595be2ca50e", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "0", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "5111d996d23b46ff80e1770e0f0d3290", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "4c092c2c4bc24327b5b6cfd58d0b1861", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "6b3127ae80c94ccba05917cc8dcbf555", + "Value": { + "$ID": "544e8a74924d4d3f94a8e64badac3573", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "66a6c980fc514480912f4fcf7eba6296", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "horizontal", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b3f7741b046942a3ac534ae99fddcbb1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ded2e38f1e28485f90a06c8f333408f2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "5814b1dd87a74ded8568f0697df3ceb7", + "Value": { + "$ID": "bc1f5fa88cef4a0f9e18d8d9affe7877", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "cd5f7792975e4eac8ff3e6416f0f3da9", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "percentage", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "e6588cd2ddaa417eb7f42e95c3343a2c", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e9783ebed60945eea7ee28013a535af1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "184cc73c595c4f7b800ac16f39cafd34", + "Value": { + "$ID": "83e51c24fca641bd8731523a42a4ea76", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d82257e2045f4a9f80aa1dc9c0b937a5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a9d27309b2214be097dcc3d2918bba07", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "30880035ca054551b07b30ecfd6422f4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "81540dfbce7147ddbbc46ddf1339e492", + "Value": { + "$ID": "1898b36152b74cd9b0945cfcfd6fb2e7", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e9e0405e0c8d4f3cab2ec52aa5f44ef7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a85e2aecf2324c4eb977e878c7e4bfbf", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "34982dee741746dba78ec516d879e64b" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/starrating.json b/modelsdk/widgets/templates/mendix-11.6/starrating.json new file mode 100644 index 00000000..e4f9364d --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/starrating.json @@ -0,0 +1,754 @@ +{ + "widgetId": "com.mendix.widget.custom.starrating.StarRating", + "name": "Rating", + "version": "11.6.4", + "extractedFrom": "9bc46bcf-8c41-4054-af2c-c4df94ada936", + "type": { + "$ID": "d338f3b4eb82412796dd827c1576cc9e", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/rating", + "ObjectType": { + "$ID": "324c7ea6f43447a4ab2774e456369d63", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "0c7a6e0a8a0d47af92a29325ed619d5d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Attribute", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "rateAttribute", + "ValueType": { + "$ID": "828e1423342d4967826177f2541d9dad", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Integer", + "Long", + "Decimal" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "4d7ce9c6cdb64510bb3f73e690a185e0", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Empty icon", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "emptyIcon", + "ValueType": { + "$ID": "4923f6d08fa845a8b611feac0103f280", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Icon" + } + }, + { + "$ID": "eb87905fe3694c9c8e3fac8ffe5169cf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Selected icon", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "icon", + "ValueType": { + "$ID": "628adfc1d80a41d3890aca43afc8d6f0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Icon" + } + }, + { + "$ID": "94f1bca690934a8f80554bb984335ed8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Amount", + "Category": "General", + "Description": "The number of rating icons", + "IsDefault": false, + "PropertyKey": "maximumStars", + "ValueType": { + "$ID": "4439b8230214425693951efae89f2726", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "5", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "79e40337bdac4edc97f26d20bb5c7ab8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Animation", + "Category": "General", + "Description": "", + "IsDefault": false, + "PropertyKey": "animation", + "ValueType": { + "$ID": "7a6a0b82ee8443eca2fdcffb8ad19069", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "995411fab6d64d199038efce1e785fed", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onChange", + "ValueType": { + "$ID": "f4a676e686af45c7ac8ae455ac693162", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "277fce3514c34b4face8d19e3da291d5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Name", + "ValueType": { + "$ID": "2a4ed057b7da454ca0d337907c3fc86b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "08d018adff5843e0accf403c51578ec4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Editability", + "ValueType": { + "$ID": "3994e69597c44540a04dfda015cf48c2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "adb30d5b2caf4d07b02ea487b6ef96eb", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Visibility", + "ValueType": { + "$ID": "25b0d32262f3482081a47d57542870ff", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "adc6e14a2d4b42d0ba45bb26a793c29e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "TabIndex", + "ValueType": { + "$ID": "8a7c75575b1c4c4b940484c150274bda", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Display", + "StudioProCategory": "Display", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.custom.starrating.StarRating", + "WidgetName": "Rating", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "30eda0a8603545328df699af4c995ab3", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "23d801b020354f008ce4cf8a259a98ee", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "0c7a6e0a8a0d47af92a29325ed619d5d", + "Value": { + "$ID": "083eb54283f3464894e427253e4457f7", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "615325777eb745cc9824751085c5c389", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "828e1423342d4967826177f2541d9dad", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f3e44eca78834d2cb5d7a1c6179db05f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4d7ce9c6cdb64510bb3f73e690a185e0", + "Value": { + "$ID": "471ad94515504a5582fb028c5ca71345", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "976b862a4b3f45aeb72d99812f2cc0d4", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4923f6d08fa845a8b611feac0103f280", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "849b3379a16a471680591d817f7119d4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "eb87905fe3694c9c8e3fac8ffe5169cf", + "Value": { + "$ID": "2df0c75221a942a7ae65c2cbab663afe", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7b211f2d8e004e9794822cdf66a56acb", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "628adfc1d80a41d3890aca43afc8d6f0", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "edf2b3b2cb1840a0976c80b1f96751eb", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "94f1bca690934a8f80554bb984335ed8", + "Value": { + "$ID": "037f1494af3f42aa9e1baa6e457f8953", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5550190a6b2c480c95d9627c8a96e44c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "5", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4439b8230214425693951efae89f2726", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2406224f710b4b399a4d146b1e4f1b7f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "79e40337bdac4edc97f26d20bb5c7ab8", + "Value": { + "$ID": "928624557f8a4125bedc79e01faf6011", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "747228a3821b474abadae5d3b443bd08", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7a6a0b82ee8443eca2fdcffb8ad19069", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8759b210cf3c4084bcbb239e9bc79b45", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "995411fab6d64d199038efce1e785fed", + "Value": { + "$ID": "733794e8557a47d1860bbfa1f15c236d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3f7b897c1a17404cbfa590fc8defd1a0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f4a676e686af45c7ac8ae455ac693162", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "324c7ea6f43447a4ab2774e456369d63" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/switch.json b/modelsdk/widgets/templates/mendix-11.6/switch.json new file mode 100644 index 00000000..44812426 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/switch.json @@ -0,0 +1,308 @@ +{ + "widgetId": "com.mendix.widget.custom.switch.Switch", + "name": "Switch", + "version": "11.6.4", + "extractedFrom": "892d009e-9c56-4629-b179-b292824910a3", + "type": { + "$ID": "1ad0e353920b44328e14773dc2ba2902", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/switch", + "ObjectType": { + "$ID": "b43c23fec9844c698d1cceb8ce3514a1", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "cc448ca6125449d5b7b41227ec84a834", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Boolean attribute", + "Category": "General::Data source", + "Description": "Attribute to toggle", + "IsDefault": false, + "PropertyKey": "booleanAttribute", + "ValueType": { + "$ID": "97b5a9fe1d6f433aa58abf7959144ecf", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "Boolean" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "bc997a0a629d419f83f0ddedac356560", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On change", + "Category": "General::Actions", + "Description": "Action to be performed when the switch is toggled", + "IsDefault": false, + "PropertyKey": "action", + "ValueType": { + "$ID": "56f7e892e0f24491a818b0a2518bba57", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + }, + { + "$ID": "49908883689b45afbcb365500ca581b1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Label", + "ValueType": { + "$ID": "d4d7da4cbe234755b0aeb94e4fdb2598", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "f5af59bc6654412490540436834ee5a7", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Editability", + "ValueType": { + "$ID": "174b6a1359d74191bf18283b8bbbdd3b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Input Elements", + "StudioProCategory": "Input elements", + "SupportedPlatform": "Web", + "WidgetDescription": "Toggle a boolean attribute", + "WidgetId": "com.mendix.widget.custom.switch.Switch", + "WidgetName": "Switch", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "7c8f3e942f524df3b92c9c5106ff4947", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "a37265a280ac45539444e119435b7ee6", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "cc448ca6125449d5b7b41227ec84a834", + "Value": { + "$ID": "ea8893e5418547e7b808ced978aeab43", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ea87264a78f94cb4978ca8362b5a3ba6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "97b5a9fe1d6f433aa58abf7959144ecf", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c4b6129b5bd34338829eb1b42ddccedd", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "bc997a0a629d419f83f0ddedac356560", + "Value": { + "$ID": "c139ce93489b420186af33fa82404f61", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ab19832e6cb249eebb62ebc36e4aa338", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "56f7e892e0f24491a818b0a2518bba57", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "b43c23fec9844c698d1cceb8ce3514a1" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/timeline.json b/modelsdk/widgets/templates/mendix-11.6/timeline.json new file mode 100644 index 00000000..66f11bd5 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/timeline.json @@ -0,0 +1,1704 @@ +{ + "widgetId": "com.mendix.widget.web.timeline.Timeline", + "name": "Timeline", + "version": "11.6.4", + "extractedFrom": "b0fcf32a-15b8-4a68-949c-5bcc1fe3528e", + "type": { + "$ID": "184dc6d1946348f0bcc94d49447ee59b", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/timeline", + "ObjectType": { + "$ID": "1afa43c6e28d4253b9ac20742a5eb2f1", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "19d63ff9d7454e7d81ac52c6645c8f7d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Data source", + "Category": "Data Source::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "data", + "ValueType": { + "$ID": "554693de7a1b42e9a9038465da569f37", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "afbbb63799d848a68070410350638574", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Title", + "Category": "Data Source::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "title", + "ValueType": { + "$ID": "e452f21c4ad041d89a37a07553f6aa67", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "data", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "b0de7994f431485899fd97c211d00fb9", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Description", + "Category": "Data Source::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "description", + "ValueType": { + "$ID": "269d023fc4d74501bc3cf0c3cef2bbd1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "data", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "d91075a0f05b40ad9005795bc396facb", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Time Indication", + "Category": "Data Source::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "timeIndication", + "ValueType": { + "$ID": "c04031d8344f48c7ba9b862cf373168b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "data", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "ac9fcc6505014adc984bb8be49d203d8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Custom Visualization", + "Category": "General::General", + "Description": "Enables free to model timeline.", + "IsDefault": false, + "PropertyKey": "customVisualization", + "ValueType": { + "$ID": "ed5f9e316b28483bb5099ebef56aa71d", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "52df8592eb5c448e85b8a5a6d6213fe5", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Icon", + "Category": "General::General", + "Description": "If no icon is configured, a circle will be rendered.", + "IsDefault": false, + "PropertyKey": "icon", + "ValueType": { + "$ID": "d4ea496118b2464f89b84418aaef8786", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Icon" + } + }, + { + "$ID": "a30c2f86a157461bb0783380db203e8d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Group Events", + "Category": "General::General", + "Description": "Shows a header between grouped events based on event date.", + "IsDefault": false, + "PropertyKey": "groupEvents", + "ValueType": { + "$ID": "a678e6ef7fa9433782f033d125d78134", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "7e4a7e0c5fbf4a3dbbaff59f0477ccf6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Group Attribute", + "Category": "General::General", + "Description": "Will be used for grouping events, as a group header value. If events have no date time value, use \"Unscheduled events placement\" to control rendering.", + "IsDefault": false, + "PropertyKey": "groupAttribute", + "ValueType": { + "$ID": "707ab4744b6d4215ba93114674dff2c0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1, + "DateTime" + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "data", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Attribute" + } + }, + { + "$ID": "31a289f2af42434aa70e0108c6836a00", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Group by", + "Category": "General::General", + "Description": "Group events based on day, month or year.", + "IsDefault": false, + "PropertyKey": "groupByKey", + "ValueType": { + "$ID": "fec33b23be2145e69bbdfbfa84866c7e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "day", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "4c8bae5cc7054624a53dd64346c7d9c4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "day", + "Caption": "Day" + }, + { + "$ID": "825309306698468498a3eac186709b6f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "month", + "Caption": "Month" + }, + { + "$ID": "752ce5198b6c4a499b95628ddb9168c9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "year", + "Caption": "Year" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "744a29d0e7674afea89f63013af79abd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Format", + "Category": "General::General", + "Description": "Format group header with current language's format", + "IsDefault": false, + "PropertyKey": "groupByDayOptions", + "ValueType": { + "$ID": "d4a933e4be40429b9ef881825ca0719e", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "dayName", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "aa7ba6ae3c4e43f59188de58f5baa683", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dayName", + "Caption": "Day name" + }, + { + "$ID": "bd54f4eb5ddb4fe795b0de62a474d1e5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dayMonth", + "Caption": "Day and month" + }, + { + "$ID": "1c9cc335229f4aa08671ea2db3ae18d4", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "fullDate", + "Caption": "Day, month, year" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "c4353ef6db284b958048c722dca3a330", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Format", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "groupByMonthOptions", + "ValueType": { + "$ID": "456763c70ddb4f04b258fdc85ec0dcd9", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "month", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "e630c817f2454ffbb81a7e10b31c82d7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "month", + "Caption": "Month" + }, + { + "$ID": "3f042476ec7344a88455a43149ee51ae", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "monthYear", + "Caption": "Month and year" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "855289ad870f49a086424828b07cc67c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Ungrouped events position", + "Category": "General::General", + "Description": "Position in the list of events without a date and time", + "IsDefault": false, + "PropertyKey": "ungroupedEventsPosition", + "ValueType": { + "$ID": "0ce4e9280e144a71840321977b2ebb1b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "end", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "321ab6be42db45a8bdf6ad9def7aef13", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "beginning", + "Caption": "Beginning of the timeline" + }, + { + "$ID": "936e7542844e4e9fa19acb7b27ea887f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "end", + "Caption": "End of the timeline" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "b39a617548134b0da0bc31ce45dd7714", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Icon", + "Category": "General::Custom", + "Description": "Content of the icon", + "IsDefault": false, + "PropertyKey": "customIcon", + "ValueType": { + "$ID": "f2b712fcdf224797823348a4037af1e2", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "data", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "2845b27254e042259f51a759688dec2a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Group header", + "Category": "General::Custom", + "Description": "Content of the group header", + "IsDefault": false, + "PropertyKey": "customGroupHeader", + "ValueType": { + "$ID": "38b632e0e5a54c3e9817c631d5f8ee4a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "data", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "9e2c30dd4f194a34be693b05e9e664cc", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Title", + "Category": "General::Custom", + "Description": "Content of the title", + "IsDefault": false, + "PropertyKey": "customTitle", + "ValueType": { + "$ID": "c85ec76495af4109ac7166ed74cbf5f0", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "data", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "913c748d93e643c0871e1b04d13b074f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Event time", + "Category": "General::Custom", + "Description": "Content of the event time", + "IsDefault": false, + "PropertyKey": "customEventDateTime", + "ValueType": { + "$ID": "19e1f012f2d547af8bd760def1488518", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "data", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "718d36da3de74138a5c64453f689af6c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Content", + "Category": "General::Custom", + "Description": "Content of the description", + "IsDefault": false, + "PropertyKey": "customDescription", + "ValueType": { + "$ID": "82f68cfb9aec4fe5bc83dd9f6f3abddc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "data", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "fbfe31150090487ea547bda1be5a12de", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "On click", + "Category": "Events", + "Description": "", + "IsDefault": false, + "PropertyKey": "onClick", + "ValueType": { + "$ID": "d2d9f58adeda477fad6dda67f4808b1b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "data", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Action" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Display", + "StudioProCategory": "Display", + "SupportedPlatform": "Web", + "WidgetDescription": "Shows vertical timeline with events", + "WidgetId": "com.mendix.widget.web.timeline.Timeline", + "WidgetName": "Timeline", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "614f17c9f8d14f9287c7c180038f7f18", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "f11314a5c3dc481ba225c867c104ca85", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "19d63ff9d7454e7d81ac52c6645c8f7d", + "Value": { + "$ID": "868d0aaae0a2463e8d9e4981dabab912", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5d91258183ab43d7a254589290233bbe", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "554693de7a1b42e9a9038465da569f37", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9562a8414a514e7292bbf95fea697a02", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "afbbb63799d848a68070410350638574", + "Value": { + "$ID": "a9e92aa4ac994363b42bbf783d0f7346", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "cd46a39b0c0c4abeaf7682b08cb3c725", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "55d1a398436e41dcbe92aa8493ba473b", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "30989a2062a3420d8a6ce0f5e6f1c8bf", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "ac46d7042f7e400b80f350c19c51da59", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "e452f21c4ad041d89a37a07553f6aa67", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "efa84cfa1ddd416ebd33101174c627b3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b0de7994f431485899fd97c211d00fb9", + "Value": { + "$ID": "c57d8291973746608df9d25942d9f770", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ac36b43b694b47428ef7c9261dea5acd", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "ad24c87db8394046b000da061ef1d653", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "77a0c7f0e2f1494aa2d66a3a7418d321", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "72f0ef1204664855b2072b45d8a62165", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "269d023fc4d74501bc3cf0c3cef2bbd1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8f461f13bd6d4b059713d8de18ff3bf7", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d91075a0f05b40ad9005795bc396facb", + "Value": { + "$ID": "e640103189e543f281eadd337a753e1b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1ac2fe0c0b3f45419af3bb2685cf1926", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "cc49b4db32104c9f900f0ac6195459dd", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "f0c7660714944424abb5aaf7407f2711", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "73799115b7e3467fadfa8623e9f92382", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "c04031d8344f48c7ba9b862cf373168b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a1390ac37199496d8acc52c7d87c0435", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ac9fcc6505014adc984bb8be49d203d8", + "Value": { + "$ID": "57057dc6b5004f078bca822dee976f18", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "b833cf27c4794cadb25cdc465de3764c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "ed5f9e316b28483bb5099ebef56aa71d", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d76f56781cfa422f81f7895e07e2f1c2", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "52df8592eb5c448e85b8a5a6d6213fe5", + "Value": { + "$ID": "8945d2755b0248f38197b232cb763566", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8518ee385ec145a4ac4c6fe6db1ea893", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d4ea496118b2464f89b84418aaef8786", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "3caf8007cb1440f18b4a5faba0227e63", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a30c2f86a157461bb0783380db203e8d", + "Value": { + "$ID": "b2c7fbbdb6424e11acb33cef3362be21", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "928757bc1e2f4bda91a66f00fd718164", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a678e6ef7fa9433782f033d125d78134", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2a7303925c864c67a9430f0be68a9a06", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "7e4a7e0c5fbf4a3dbbaff59f0477ccf6", + "Value": { + "$ID": "d2f7ce68b1e145d5a4b430f649305b51", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "90a2fa097a434d37810e0ad48201dd54", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "707ab4744b6d4215ba93114674dff2c0", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "635c71ac786e42d4bf42e59c38b7a636", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "31a289f2af42434aa70e0108c6836a00", + "Value": { + "$ID": "f30c2df45aa54a25915a4df3db47b69b", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "22139a29618f49bd8345f0d66b9c3caf", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "day", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fec33b23be2145e69bbdfbfa84866c7e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "8cc62f2ffbb7450fbaad3395860071c0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "744a29d0e7674afea89f63013af79abd", + "Value": { + "$ID": "8df9465d2a434303a2eebe61d05bf5dc", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "d8090d8e46ff4672858b29bcf5b0dfca", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "dayName", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d4a933e4be40429b9ef881825ca0719e", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "de17e10486d44c6b894ea9482c62a1f9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "c4353ef6db284b958048c722dca3a330", + "Value": { + "$ID": "3d4a210d1a984813b9e024594fa7e9f3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "7be3685334ec42b7b779df44742866cf", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "month", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "456763c70ddb4f04b258fdc85ec0dcd9", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9c254a37a023454183bca02d303c46e4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "855289ad870f49a086424828b07cc67c", + "Value": { + "$ID": "65104003151141edb7635dc76891fb4a", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "553aed8874424b4b8e6cae83ac650aca", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "end", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "0ce4e9280e144a71840321977b2ebb1b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "31fcb0b40daf4dc7b59b63f0a9729def", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b39a617548134b0da0bc31ce45dd7714", + "Value": { + "$ID": "717ab523f88643558ca3ea23974daa1c", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "46fff1a1b0134c31952c0c2d092801f5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f2b712fcdf224797823348a4037af1e2", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "80fcb36b285149db8d66ff8c9cd17160", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2845b27254e042259f51a759688dec2a", + "Value": { + "$ID": "7a4c93c8aedc4cee899f95ed88a44f10", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "09c7fda9573246e0a139511614b7b8c3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "38b632e0e5a54c3e9817c631d5f8ee4a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "bc479c7a631a49e3bfa70cd4b6a3149d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "9e2c30dd4f194a34be693b05e9e664cc", + "Value": { + "$ID": "4b9ad1a5f1b343f4abe597a6d3aeb860", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0c2604fbf93f4916888bd3786cc7c16d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c85ec76495af4109ac7166ed74cbf5f0", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "3a15566d9251493e98d3dbffe557c089", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "913c748d93e643c0871e1b04d13b074f", + "Value": { + "$ID": "2f82d9cd8de74b8b8abd7dc75736ddbe", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "eddbe48dba034858b5d594ddb2a5ced0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "19e1f012f2d547af8bd760def1488518", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e2308ad668f84a64b530aa181f2b4f4b", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "718d36da3de74138a5c64453f689af6c", + "Value": { + "$ID": "a2fb8b30a7d64560b970570d58dcedb1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "09b3fa71577a4a9fbebe5871a52f260d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "82f68cfb9aec4fe5bc83dd9f6f3abddc", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "404d47e9a8fa43c18d6ec9f1e1a5da06", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "fbfe31150090487ea547bda1be5a12de", + "Value": { + "$ID": "03ae48b129fa4423bae45b7b28bcf3bf", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "2ee14dd2fa9149cbbcc94db5c89fa9cc", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "d2d9f58adeda477fad6dda67f4808b1b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "1afa43c6e28d4253b9ac20742a5eb2f1" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/tooltip.json b/modelsdk/widgets/templates/mendix-11.6/tooltip.json new file mode 100644 index 00000000..cfe9bca0 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/tooltip.json @@ -0,0 +1,729 @@ +{ + "widgetId": "com.mendix.widget.web.tooltip.Tooltip", + "name": "Tooltip", + "version": "11.6.4", + "extractedFrom": "4f015d39-33a2-4eb7-af2f-690843711c8b", + "type": { + "$ID": "560879b62ab84f138cd8614bc8baf444", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/tooltip", + "ObjectType": { + "$ID": "24ab3251545e4dc68fcb27cec359bd7b", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "a8b62c57b6904bb09d92476001b62465", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Trigger: place widgets here", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "trigger", + "ValueType": { + "$ID": "f35d6d9ae4394e258aa2df3eb4f116ca", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "951b5df1e633490284aad752ea0e929a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Render method", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "renderMethod", + "ValueType": { + "$ID": "f9c2984344e74e61b4fb4c6ec0a1ccab", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "text", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "d034622ffb31449f9f035ddadc03a90d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "text", + "Caption": "Text" + }, + { + "$ID": "0113ff5262504cd680754b7b6106558f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "custom", + "Caption": "Custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "88fb6fc6d7494b95aac9ff432e15e0bb", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip content: place widgets here", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "htmlMessage", + "ValueType": { + "$ID": "3237602ef2394bc698b485ebe4ae9fab", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "bf40f8b60ae1422eaaabbd8ef19706bd", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "textMessage", + "ValueType": { + "$ID": "6a30920dcd0e46ef87733da04bd36147", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "378a7fbb8b0d4049bdf043595d1b2d18", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Tooltip position", + "Category": "General::General", + "Description": "How to position the tooltip in relation to the trigger element - at the top, to the left, at the bottom or to the right.", + "IsDefault": false, + "PropertyKey": "tooltipPosition", + "ValueType": { + "$ID": "7b2c6334d9dd413e84fdc2d4a95293f7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "top", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "ee588bd6708c4fcda2d054f997ba4978", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "left", + "Caption": "Left" + }, + { + "$ID": "aa7b3580e1d94131a8322634750ec71a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "right", + "Caption": "Right" + }, + { + "$ID": "858291e8f2f54f0db5e4eca85180e580", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "top", + "Caption": "Top" + }, + { + "$ID": "0dafcac23fa9460389eaeebf3e95c33d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "bottom", + "Caption": "Bottom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "b8bf64d2d6a4433e8850cbecbdf71c39", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Arrow position", + "Category": "General::General", + "Description": "How to position the tooltip arrow in relation to the tooltip - at the start, in the center or at the end.", + "IsDefault": false, + "PropertyKey": "arrowPosition", + "ValueType": { + "$ID": "6883a5d76641496ca21e2c6d1421d481", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "none", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "1812b4df51864a92b6bf083869f5950c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "start", + "Caption": "Start" + }, + { + "$ID": "2c0c426d2a2c4467b9add444bfbd6ab1", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "none", + "Caption": "Center" + }, + { + "$ID": "dea4532597864417b5bf82cfd2057ec8", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "end", + "Caption": "End" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "268180791bd449d5aec5284e0c30f900", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Open on", + "Category": "General::General", + "Description": "How the tooltip is triggered - click, hover, hover and focus. On mobile device “hover” will be triggered on touch.", + "IsDefault": false, + "PropertyKey": "openOn", + "ValueType": { + "$ID": "7668899e43e441afb54cd99e240a14fe", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "hover", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "8fca70961cf34f99ac730434dc6b0ea2", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "click", + "Caption": "Click" + }, + { + "$ID": "750d81fb279f4555a627588c1b2aaa16", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "hover", + "Caption": "Hover" + }, + { + "$ID": "93cb392cc8b4477a93ae8798cedabb6f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "hoverFocus", + "Caption": "Hover,focus" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Display", + "StudioProCategory": "Display", + "SupportedPlatform": "Web", + "WidgetDescription": "", + "WidgetId": "com.mendix.widget.web.tooltip.Tooltip", + "WidgetName": "Tooltip", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "5bd0294363d64bf383e204ea27bcecdb", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "19a198bc0e3242a299686e25861749ab", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a8b62c57b6904bb09d92476001b62465", + "Value": { + "$ID": "ff66a7490c9344b2bbbd8bb36338ee7d", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "f84b057c38bb470480254f2730285feb", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f35d6d9ae4394e258aa2df3eb4f116ca", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "513690104e3542ff92d6d213dccf0e00", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "951b5df1e633490284aad752ea0e929a", + "Value": { + "$ID": "6449aa15738f4257b9a47de2b6f21055", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "596a40a2d0564af69ce31d514e88b7de", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "text", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f9c2984344e74e61b4fb4c6ec0a1ccab", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "53bea560af6e4f7d8954e04dd21224e3", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "88fb6fc6d7494b95aac9ff432e15e0bb", + "Value": { + "$ID": "f1fca24e44d54f639488ca65fea47923", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e32820d5494c475bab6907548ff893b0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "3237602ef2394bc698b485ebe4ae9fab", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e37892fc6e0c47a59d19724ff01bb19f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "bf40f8b60ae1422eaaabbd8ef19706bd", + "Value": { + "$ID": "e43ae59b81c6413eb788e17c7c6472cb", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "145a5e9cfd2b45a09af74f45cd3cefe2", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "0cdbcfbabd094852adc75e3f57ecb7e5", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "03a228b1f7c44188a1b976996fe44662", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "bef48141fc314b329559b46884830fa9", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "6a30920dcd0e46ef87733da04bd36147", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a4621a65469b4480a86bea98abeccc5c", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "378a7fbb8b0d4049bdf043595d1b2d18", + "Value": { + "$ID": "8c2183af27454709a6a46c9f90d136ce", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "323a1ef73e494bd18137ac3e2602db86", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "top", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7b2c6334d9dd413e84fdc2d4a95293f7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "16371353c99949b0b635502bfb2ce450", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "b8bf64d2d6a4433e8850cbecbdf71c39", + "Value": { + "$ID": "d2a610b0d7a74f6895c0b6127702ec6f", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4c97c1aeb76a4e5fbe09866de7b0ff29", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "none", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "6883a5d76641496ca21e2c6d1421d481", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "c7c65ed0ba6e4040ba678d5ba8890470", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "268180791bd449d5aec5284e0c30f900", + "Value": { + "$ID": "e7bd27a75474469c97826d2a90ede858", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "12e69531f29e4259a1fd514df46e9a08", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "hover", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7668899e43e441afb54cd99e240a14fe", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "24ab3251545e4dc68fcb27cec359bd7b" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/treenode.json b/modelsdk/widgets/templates/mendix-11.6/treenode.json new file mode 100644 index 00000000..0a47e61e --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/treenode.json @@ -0,0 +1,1301 @@ +{ + "widgetId": "com.mendix.widget.web.treenode.TreeNode", + "name": "Tree node", + "version": "11.6.4", + "extractedFrom": "8269c38f-fdb6-4fe0-a1e2-b41a065a3e84", + "type": { + "$ID": "9ec4732dd8b245609fc274a9af6df600", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/modules/tree-node", + "ObjectType": { + "$ID": "2359b983c2d34ab69b2673cf54c625a6", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "812a6c50e43144a3ba29f6eca89ac89d", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Enable advanced options", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "advancedMode", + "ValueType": { + "$ID": "f046c3367f734b0f98cc9aa76fdaddb3", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "e720a6d812a0401db3fc9487427c034e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Data source", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "datasource", + "ValueType": { + "$ID": "8f557050885843fb84833be8ddf63933", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": true, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "DataSource" + } + }, + { + "$ID": "0976e31159104a06a9b625989d6c80a6", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Header type", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "headerType", + "ValueType": { + "$ID": "57d870052fc8448b826002b78450747a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "text", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "9e4af120e116434bbbcf69e2d9f1b5af", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "text", + "Caption": "Text" + }, + { + "$ID": "90c0d6e2821e44cfa8ec7a3b52a497a7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "custom", + "Caption": "Custom" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "2ea7a94a96e548e2a0b6bff28d56aca4", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Open node when", + "Category": "General::General", + "Description": "Define which part of the node, when clicked, should open or close this node. \"Header is clicked\" means the whole header is clickable, while \"Icon is clicked\" means only the icon is used to switch node state.", + "IsDefault": false, + "PropertyKey": "openNodeOn", + "ValueType": { + "$ID": "c78583a36f204b0199a86230d6723015", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "headerClick", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "451523bee1db49638d34d62821828ed3", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "headerClick", + "Caption": "Header is clicked" + }, + { + "$ID": "dcdcf474cddb4573beec41acc6825d7c", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "iconClick", + "Caption": "Icon is clicked" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "3bfc7455b6c44fa4a8e6f21049a42c1a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Header", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "headerContent", + "ValueType": { + "$ID": "26d6848a9d734cc9b182d1f206216dab", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "eef01afb0e134f04a16455945ed129f8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Header caption", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "headerCaption", + "ValueType": { + "$ID": "245d6f1d71f64be4b155d9829b4e8be8", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "2b770a3842644aafb59e8689168b4137", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Has children", + "Category": "General::General", + "Description": "Indicate whether the node has children or is an end node. When set to yes, a composable region becomes available to define the child nodes.", + "IsDefault": false, + "PropertyKey": "hasChildren", + "ValueType": { + "$ID": "a66f96592f784b6f9116e52526cc8585", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "a6b6d6ca8f0644e38a65e0a1847ad82b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Start expanded", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "startExpanded", + "ValueType": { + "$ID": "559f136f576e423fb51ad0232c73e460", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "105e9cd41d234987bd8e97b597cbb7a2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Place other Tree nodes here", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "children", + "ValueType": { + "$ID": "80b3344487ff49c3b78f6195dc83a020", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "datasource", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Widgets" + } + }, + { + "$ID": "33e49b4d10f7479a8b5851ada50693b2", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Animate", + "Category": "General::General", + "Description": "", + "IsDefault": false, + "PropertyKey": "animate", + "ValueType": { + "$ID": "1eaf5c89e89648eeb5747802261c9249", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "63a7824cc65a4174a2c71af8a19dbb2e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show icon", + "Category": "Visualization::Icon", + "Description": "", + "IsDefault": false, + "PropertyKey": "showIcon", + "ValueType": { + "$ID": "b84b0744edc3460990d0808e3d987bd1", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "left", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "805af42ce851481cb84e93e213d20352", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "left", + "Caption": "Left" + }, + { + "$ID": "d3409627a3714a2bbc130460efe69445", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "right", + "Caption": "Right" + }, + { + "$ID": "4ee386a0fbd94058a02004360aacd5f9", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "no", + "Caption": "No" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "83a859d9e1bb414ab284c8a170f53a63", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Expanded icon", + "Category": "Visualization::Icon", + "Description": "", + "IsDefault": false, + "PropertyKey": "expandedIcon", + "ValueType": { + "$ID": "a4ff1df26dd94e009bcae57999b77b5a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Icon" + } + }, + { + "$ID": "e66b8be3deff48d6adbfa54f754d751c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Collapsed icon", + "Category": "Visualization::Icon", + "Description": "", + "IsDefault": false, + "PropertyKey": "collapsedIcon", + "ValueType": { + "$ID": "dbb81ee336f748cb88071648975a96a7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Icon" + } + }, + { + "$ID": "3223806ef7aa4b05904deec82e8b4c97", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Animate icon", + "Category": "Visualization::Icon", + "Description": "Animate the icon when the group is collapsing or expanding.", + "IsDefault": false, + "PropertyKey": "animateIcon", + "ValueType": { + "$ID": "fd99c1b606194d499cd2c63276ee49d6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Data Containers", + "StudioProCategory": "Data containers", + "SupportedPlatform": "Web", + "WidgetDescription": "Display a tree view structure", + "WidgetId": "com.mendix.widget.web.treenode.TreeNode", + "WidgetName": "Tree node", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "7af71c3c8ef54d359f05c101f17979a4", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "8f9ca7f275dc41b28733c29c239ebe10", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "812a6c50e43144a3ba29f6eca89ac89d", + "Value": { + "$ID": "852a439cc20b431aa776f2bb85d66d9e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "69952a53622d44bbb92aca1d44f4226d", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f046c3367f734b0f98cc9aa76fdaddb3", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "7eef13a0d8ce4f14ae469376a8dc808e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e720a6d812a0401db3fc9487427c034e", + "Value": { + "$ID": "505440b7aaa24f2faaf5aa0fa753de50", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "345a54bae2454357992ae8e4dfdb3864", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8f557050885843fb84833be8ddf63933", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "6115d4a79b4243beacf9662c7380afe0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "0976e31159104a06a9b625989d6c80a6", + "Value": { + "$ID": "f6c0397b520f44a8a09d53d6a3d82c62", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "dc5e11b49a394144b7e16abde4315ef3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "text", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "57d870052fc8448b826002b78450747a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "24892a00843c4df3a8fc16dcd89453b4", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2ea7a94a96e548e2a0b6bff28d56aca4", + "Value": { + "$ID": "5deea0a38f204ff68770765b46acfad5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "4a9543cdb9b24685994ed8f3d808f63c", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "headerClick", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "c78583a36f204b0199a86230d6723015", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "20e8527d5caf493eb0966f537c9c4d74", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3bfc7455b6c44fa4a8e6f21049a42c1a", + "Value": { + "$ID": "7a7dc6f27dee4ed29622948bc979be06", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "bebbd5fe5aeb4d2b8066c80a4d10ac64", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "26d6848a9d734cc9b182d1f206216dab", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "b7c242eeed9d4708aa04734fb1d93e00", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "eef01afb0e134f04a16455945ed129f8", + "Value": { + "$ID": "97bbbaf341854244bcfb1c9937f85082", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1a271c1a3d224d22ae4bd8db35780649", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "98661c0b53e54684a378e45c4607f0f5", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "b8dbad92775b4ca48b88e98f56dc6a84", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "12c463b6f95540faa498f524b3ea16eb", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "245d6f1d71f64be4b155d9829b4e8be8", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1a8d4bdd0b094906952046a4989d6e24", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "2b770a3842644aafb59e8689168b4137", + "Value": { + "$ID": "9768c7a6cbc34fffac89e97a41c1e300", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "06a417e911fd439280c1b3e1952ae253", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a66f96592f784b6f9116e52526cc8585", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "cb7b8e2e39eb4aa19e099eb6d4c989af", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "a6b6d6ca8f0644e38a65e0a1847ad82b", + "Value": { + "$ID": "2c71f97e14de47dc93353777a8abd0fe", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "dfbdc8f1115e49c7b8a9d67127a723a3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "559f136f576e423fb51ad0232c73e460", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f17ede9f9d87462e9719ca938d63ac52", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "105e9cd41d234987bd8e97b597cbb7a2", + "Value": { + "$ID": "5a754b3e53f041ea838df33302e5b366", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5969a0a8765d486695986e39fb6d7acd", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "80b3344487ff49c3b78f6195dc83a020", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "eebddf5a3b614469ac721a6fb9c84ab1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "33e49b4d10f7479a8b5851ada50693b2", + "Value": { + "$ID": "841e353c78dc4fdc875f8a95c82dd3c2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "0a53a767e0834888a464b25fcbb21767", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1eaf5c89e89648eeb5747802261c9249", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e9649ea13d274c9d918b57e0a7a5ae5e", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "63a7824cc65a4174a2c71af8a19dbb2e", + "Value": { + "$ID": "fabd63ed1a924718b92e1b17b681350e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "5379b763077b4b96994d34ddd9db29e8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "left", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "b84b0744edc3460990d0808e3d987bd1", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a99c84701aeb4a40a481499894486110", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "83a859d9e1bb414ab284c8a170f53a63", + "Value": { + "$ID": "fc81b419a0f1442a918d28d01faf02a9", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "40e42b94547d4fbba712022e203fdab4", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "a4ff1df26dd94e009bcae57999b77b5a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "2a284c057c294818a5d795a99408dc9d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "e66b8be3deff48d6adbfa54f754d751c", + "Value": { + "$ID": "e6fed53810b54b2b940f6cdb049251a8", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "aafd3c5e8b1147ddaa9b21a2abf91a4a", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "dbb81ee336f748cb88071648975a96a7", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "64fe988473a14249ba91c1b7606802a0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3223806ef7aa4b05904deec82e8b4c97", + "Value": { + "$ID": "82354034f3854d3b9a33292773f91ace", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e896bb159e6a49c4aeaaa397f32ddcf0", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "fd99c1b606194d499cd2c63276ee49d6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "2359b983c2d34ab69b2673cf54c625a6" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/templates/mendix-11.6/videoplayer.json b/modelsdk/widgets/templates/mendix-11.6/videoplayer.json new file mode 100644 index 00000000..3c39fe73 --- /dev/null +++ b/modelsdk/widgets/templates/mendix-11.6/videoplayer.json @@ -0,0 +1,1577 @@ +{ + "widgetId": "com.mendix.widget.web.videoplayer.VideoPlayer", + "name": "Video Player", + "version": "11.6.4", + "extractedFrom": "6d434a2a-15a8-42b5-bd7b-8b995ee9855c", + "type": { + "$ID": "960bdb3d73df47febe94fccc62abd9c7", + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": "https://docs.mendix.com/appstore/widgets/video-player", + "ObjectType": { + "$ID": "94f0089cafee44ada4063ac4352077ae", + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [ + 2, + { + "$ID": "11e8f127b0594a7b8a38d28da013958f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Type", + "Category": "General::Data source", + "Description": "", + "IsDefault": false, + "PropertyKey": "type", + "ValueType": { + "$ID": "25c43c5eff884daf9c2c70adea183f80", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "dynamic", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "14bde80064dd462cb47def3fd200ca21", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "dynamic", + "Caption": "Dynamic" + }, + { + "$ID": "8566346d4ad942f996cfdcf9a55790a5", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "expression", + "Caption": "Expression" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "0497ba1d44c441b392431b9e1f329319", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Video URL", + "Category": "General::Data source", + "Description": "The web address of the video: YouTube, Vimeo, Dailymotion or MP4.", + "IsDefault": false, + "PropertyKey": "urlExpression", + "ValueType": { + "$ID": "9cb2c6eab3674170b1fd46bad3e59b7f", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "f8a7f246e3514c2b957392a73386f9b1", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "fa7e2fb0875a4d3c91167dc3189d6c21", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Poster URL", + "Category": "General::Data source", + "Description": "The web address of the poster image. A poster image is a custom preview image that will be shown in the player until the user starts the video.", + "IsDefault": false, + "PropertyKey": "posterExpression", + "ValueType": { + "$ID": "7979bcb095014e27a4f89155002bb652", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": { + "$ID": "3f6702f35e89484991a53d9359625112", + "$Type": "CustomWidgets$WidgetReturnType", + "AssignableTo": "", + "EntityProperty": "", + "IsList": false, + "Type": "String" + }, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Expression" + } + }, + { + "$ID": "ae1c3a4274c54b36bf580a1a04cd2641", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Video URL", + "Category": "General::Data source", + "Description": "The web address of the video: YouTube, Vimeo, Dailymotion or MP4.", + "IsDefault": false, + "PropertyKey": "videoUrl", + "ValueType": { + "$ID": "3118c87b0cf547f7a644f8f7a598f436", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "36ab38130da8481385a67a792a5f7f1e", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Poster URL", + "Category": "General::Data source", + "Description": "The web address of the poster image. A poster image is a custom preview image that will be shown in the player until the user starts the video.", + "IsDefault": false, + "PropertyKey": "posterUrl", + "ValueType": { + "$ID": "7d7679601a4d47aab1498351a8cb568a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "48a4ae823abc48e1b0baef0665463fe1", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "Name", + "ValueType": { + "$ID": "51b212b11461431590506bdb1d168bb7", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "aa409fe63e864c08b6db42f38572a509", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "", + "Category": "General::Common", + "Description": "", + "IsDefault": false, + "PropertyKey": "TabIndex", + "ValueType": { + "$ID": "d5186b298ef14fc29e766a1a7481766a", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "System" + } + }, + { + "$ID": "48d78e6f19d14dfebeccdd4cc1f58ad8", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Title", + "Category": "Accessibility::Accessibility", + "Description": "Describe the purpose of the video (e.g., 'Video tutorial on accessibility').", + "IsDefault": false, + "PropertyKey": "iframeTitle", + "ValueType": { + "$ID": "a1721abae4754a039fbdacdde79091ef", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": false, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "TextTemplate" + } + }, + { + "$ID": "8f3a0e561cb9434bb45ad8a48029352f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Auto start", + "Category": "Controls::Controls", + "Description": "Automatically start playing the video when the page loads.", + "IsDefault": false, + "PropertyKey": "autoStart", + "ValueType": { + "$ID": "7f72bdb3ff784995ba9d0cc5d0aa61e6", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "1b621081fbf44996b8a0fffb317ea630", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Show Controls", + "Category": "Controls::Controls", + "Description": "Display video controls (control bar, display icons, dock buttons). Available for YouTube, Dailymotion and external videos.", + "IsDefault": false, + "PropertyKey": "showControls", + "ValueType": { + "$ID": "f9c7e6b948c74412ba59f05a458d9bdc", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "true", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "ff5dbae552e446e284308eac8d8c809f", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Muted", + "Category": "Controls::Controls", + "Description": "Start the video on mute.", + "IsDefault": false, + "PropertyKey": "muted", + "ValueType": { + "$ID": "f08b8ea82ea44a2c9f0844bddda6bdeb", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "d48a99f07d254cf0b62608d8eef71e0c", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Loop", + "Category": "Controls::Controls", + "Description": "Loop the video after it finishes. Available for YouTube, Vimeo, and external videos.", + "IsDefault": false, + "PropertyKey": "loop", + "ValueType": { + "$ID": "1a552606355b41f9a96552f326f25b8b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "false", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Boolean" + } + }, + { + "$ID": "82910e871ec843d289828bd321d0265b", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Width Unit", + "Category": "Dimensions::Dimensions", + "Description": "Percentage: portion of parent size. Pixels: absolute amount of pixels.", + "IsDefault": false, + "PropertyKey": "widthUnit", + "ValueType": { + "$ID": "be89bb4d2b0c432dabc322a250527c99", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "percentage", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "80579de54491416a8e96c928a2f8cd33", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentage", + "Caption": "Percentage" + }, + { + "$ID": "946ffd6fb26048f5a8df78ccd1c3975a", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "pixels", + "Caption": "Pixels" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "4d7bff0a1c1141dca7cfe41837fc5d13", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Width", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "width", + "ValueType": { + "$ID": "8f78562ba1f04ba5854cf7805123bf10", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "100", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + }, + { + "$ID": "317c47a22909457badcf57b393a7cbcf", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height unit", + "Category": "Dimensions::Dimensions", + "Description": "Aspect ratio: ratio of width to height. Percentage of parent: portion of parent height. Percentage of width: portion of the width. Pixels: absolute amount of pixels.", + "IsDefault": false, + "PropertyKey": "heightUnit", + "ValueType": { + "$ID": "74f5a395897941ba8026facb0d06a95b", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "aspectRatio", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "8691d286f2e54b249b4e105ef594f438", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "aspectRatio", + "Caption": "Aspect ratio" + }, + { + "$ID": "811d7193510d47579e63d5f29cc0e53e", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentageOfParent", + "Caption": "Percentage of parent" + }, + { + "$ID": "9da26f1eff564a4dae1cb374af2eb471", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "percentageOfWidth", + "Caption": "Percentage of width" + }, + { + "$ID": "1090815ab2dc4653864d64a0e7a42da7", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "pixels", + "Caption": "Pixels" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "f122349ca9544663a55a8058ce1a070a", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Aspect ratio", + "Category": "Dimensions::Dimensions", + "Description": "16:9 (Widescreen, HD Video), 4:3 (Classic TV, Standard monitor), 3:2 (Classic film), 21:9 (Cinemascope), 1:1 (Square, Social media)", + "IsDefault": false, + "PropertyKey": "heightAspectRatio", + "ValueType": { + "$ID": "4f1b1332552e43eaa63ebc3c5ed15a60", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "sixteenByNine", + "EntityProperty": "", + "EnumerationValues": [ + 2, + { + "$ID": "36bcb0af439c48f686093d7ebaf788fe", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "sixteenByNine", + "Caption": "16:9" + }, + { + "$ID": "1a9d474b92914d6ba9cfc2206a5d9a66", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "fourByThree", + "Caption": "4:3" + }, + { + "$ID": "54a7b18502484356bc97a22132884f67", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "threeByTwo", + "Caption": "3:2" + }, + { + "$ID": "56b73b5b7a574394ae4014e9044ad34d", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "TwentyOneByNine", + "Caption": "21:9" + }, + { + "$ID": "afd2c0f1b5d345ab9c579a3f3210dd1f", + "$Type": "CustomWidgets$WidgetEnumerationValue", + "_Key": "oneByOne", + "Caption": "1:1" + } + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Enumeration" + } + }, + { + "$ID": "3440354b7f3d45cd9986c1f962d12275", + "$Type": "CustomWidgets$WidgetPropertyType", + "Caption": "Height", + "Category": "Dimensions::Dimensions", + "Description": "", + "IsDefault": false, + "PropertyKey": "height", + "ValueType": { + "$ID": "8af4ba7da8ae428f9a339b402037a4df", + "$Type": "CustomWidgets$WidgetValueType", + "ActionVariables": [ + 2 + ], + "AllowedTypes": [ + 1 + ], + "AllowNonPersistableEntities": false, + "AssociationTypes": [ + 1 + ], + "DataSourceProperty": "", + "DefaultType": "None", + "DefaultValue": "500", + "EntityProperty": "", + "EnumerationValues": [ + 2 + ], + "IsLinked": false, + "IsList": false, + "IsMetaData": false, + "IsPath": "No", + "Multiline": false, + "ObjectType": null, + "OnChangeProperty": "", + "ParameterIsList": false, + "PathType": "None", + "Required": true, + "ReturnType": null, + "SelectableObjectsProperty": "", + "SelectionTypes": [ + 1 + ], + "SetLabel": false, + "Translations": [ + 2 + ], + "Type": "Integer" + } + } + ] + }, + "OfflineCapable": true, + "StudioCategory": "Images, Videos & Files", + "StudioProCategory": "Images, videos & files", + "SupportedPlatform": "Web", + "WidgetDescription": "Shows a video from YouTube, Vimeo, Dailymotion and Mp4", + "WidgetId": "com.mendix.widget.web.videoplayer.VideoPlayer", + "WidgetName": "Video Player", + "WidgetNeedsEntityContext": true, + "WidgetPluginWidget": true + }, + "object": { + "$ID": "9d2bb15971974c0b91458673da63153c", + "$Type": "CustomWidgets$WidgetObject", + "Properties": [ + 2, + { + "$ID": "cb8e3d0003b14ad99cfe9e326bda0ce5", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "11e8f127b0594a7b8a38d28da013958f", + "Value": { + "$ID": "9c62b7c2e0c848a184d481b205e210f2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c55c8faa38674913967d068b7744b5ea", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "dynamic", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "25c43c5eff884daf9c2c70adea183f80", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "9137ae1ef6004c96a9e4359d3bed5581", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "0497ba1d44c441b392431b9e1f329319", + "Value": { + "$ID": "365180513a8247eeab3a6782bb10dd54", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "869f01fc31ba4b86beffbb8511e423b8", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "9cb2c6eab3674170b1fd46bad3e59b7f", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d00fe1c049eb4df98a168a78e10b439d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "fa7e2fb0875a4d3c91167dc3189d6c21", + "Value": { + "$ID": "235a2088907c42d482629ddd400ed0bf", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "29619f22839842d2aa42eba0c88267ad", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7979bcb095014e27a4f89155002bb652", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "05e1475639af4d648f2e48ec09f0622d", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ae1c3a4274c54b36bf580a1a04cd2641", + "Value": { + "$ID": "bbf0f503a32b4e8ebb7d340a6309a6b6", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c31c517db76c43e080ee1429229eabc7", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "79da05ea7b7c48fb933bb1c2fc3e87c2", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "87844948ac794aa989e69eecbf5f9fb3", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "5aa75603ecd74b4594bb4735fe2b214d", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "3118c87b0cf547f7a644f8f7a598f436", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "23e047ed0f05482095d90b4c387b3c2f", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "36ab38130da8481385a67a792a5f7f1e", + "Value": { + "$ID": "bbde214adb934bad9f05b4909b852104", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "964abadaf6994983b91bdc3f051e3be1", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "d8bd6652cf784cae960962e771840921", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "4dd685d1ea6c4f12bcc0cdc987e2449a", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "4acee6fd49b7425288a89b4b21d64da3", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "7d7679601a4d47aab1498351a8cb568a", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f76c397208ca4d9ab52e6df36794bfe5", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "48d78e6f19d14dfebeccdd4cc1f58ad8", + "Value": { + "$ID": "9308dc794a6a438b9e7f6cdbe942bd85", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "1873a1a4d7764e8cae4c9d85d940ed30", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": { + "$ID": "6af77669debd4d0db1ac55507cfe2876", + "$Type": "Forms$ClientTemplate", + "Fallback": { + "$ID": "1b193955ec1b4b55960c40a8111b8d1d", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + }, + "Parameters": [ + 2 + ], + "Template": { + "$ID": "710b08c271804730bea0a7c8b1401a03", + "$Type": "Texts$Text", + "Items": [ + 3 + ] + } + }, + "TranslatableValue": null, + "TypePointer": "a1721abae4754a039fbdacdde79091ef", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "a650cfac67a94fafae345b8c43a28909", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "8f3a0e561cb9434bb45ad8a48029352f", + "Value": { + "$ID": "5e6c8927a30a4a5c8e8c3e38695829d1", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "84038bc3e4234a5cae6c97c1353efda5", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "7f72bdb3ff784995ba9d0cc5d0aa61e6", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "d751301e1fe244e2b3e26eade586f468", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "1b621081fbf44996b8a0fffb317ea630", + "Value": { + "$ID": "20aef47a1b6e490e88bb873baea46ba4", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "ad366d6be3d24fab8eca5f5694bc9a96", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "true", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f9c7e6b948c74412ba59f05a458d9bdc", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "f9367b94e78a47d3a88d1d397efd11a9", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "ff5dbae552e446e284308eac8d8c809f", + "Value": { + "$ID": "32edab3e533f40d18d4258ce77473bb3", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8f0c5a46886f4453bcb731823c01dfef", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "f08b8ea82ea44a2c9f0844bddda6bdeb", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "1641556b01174399aac2fa86280a5102", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "d48a99f07d254cf0b62608d8eef71e0c", + "Value": { + "$ID": "817235e78c2f42e5b46c43fea5deb67e", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "949ee74ce7194f4a90d6e007eab1bdd6", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "false", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "1a552606355b41f9a96552f326f25b8b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ee111b5b49054b14b1c4d35ec58327b0", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "82910e871ec843d289828bd321d0265b", + "Value": { + "$ID": "40ecfca0cfc646ee9faa4147c4d56420", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "69d9a7d1c7d04a87aa98a83665f5a2b3", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "percentage", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "be89bb4d2b0c432dabc322a250527c99", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "ddb4943c3b674aff84b9fcc01beee4bc", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "4d7bff0a1c1141dca7cfe41837fc5d13", + "Value": { + "$ID": "fb1b2ae207164edf97ca35b145ebe1ef", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "c2f080f7a08749299f417465d89b7acb", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "100", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8f78562ba1f04ba5854cf7805123bf10", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "e0320096cf954d2b92b795ad85b24b12", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "317c47a22909457badcf57b393a7cbcf", + "Value": { + "$ID": "09c74b4499ca4b3a992b4080897ea9d2", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "e496220879fb443e893578f10890ce58", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "aspectRatio", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "74f5a395897941ba8026facb0d06a95b", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "69a875906e604db198db1b7806687be1", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "f122349ca9544663a55a8058ce1a070a", + "Value": { + "$ID": "7f1d84232a4c455c88df0d9a56f2d303", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "8f432a0ce3ff41f997ccf6cfb1656f24", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "sixteenByNine", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "4f1b1332552e43eaa63ebc3c5ed15a60", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + }, + { + "$ID": "34c8700214bf4164a74f853e18d60359", + "$Type": "CustomWidgets$WidgetProperty", + "TypePointer": "3440354b7f3d45cd9986c1f962d12275", + "Value": { + "$ID": "7e2ead1cca7c489bba90ebb9fcf708c5", + "$Type": "CustomWidgets$WidgetValue", + "Action": { + "$ID": "3c37767501c943b0ad34466e99b34728", + "$Type": "Forms$NoAction", + "DisabledDuringExecution": true + }, + "AttributeRef": null, + "DataSource": null, + "EntityRef": null, + "Expression": "", + "Form": "", + "Icon": null, + "Image": "", + "Microflow": "", + "Nanoflow": "", + "Objects": [ + 2 + ], + "PrimitiveValue": "500", + "Selection": "None", + "SourceVariable": null, + "TextTemplate": null, + "TranslatableValue": null, + "TypePointer": "8af4ba7da8ae428f9a339b402037a4df", + "Widgets": [ + 2 + ], + "XPathConstraint": "" + } + } + ], + "TypePointer": "94f0089cafee44ada4063ac4352077ae" + } +} \ No newline at end of file diff --git a/modelsdk/widgets/walker.go b/modelsdk/widgets/walker.go new file mode 100644 index 00000000..1893cc4b --- /dev/null +++ b/modelsdk/widgets/walker.go @@ -0,0 +1,185 @@ +// SPDX-License-Identifier: Apache-2.0 + +package widgets + +import "github.com/mendixlabs/mxcli/modelsdk/widgets/mpk" + +// findPropertyType finds a PropertyType map by PropertyKey in a PropertyTypes array. +func findPropertyType(propTypes []any, key string) (ptMap map[string]any, ptID string) { + for _, pt := range propTypes { + m, ok := pt.(map[string]any) + if !ok { + continue + } + k, _ := m["PropertyKey"].(string) + if k == key { + id, _ := m["$ID"].(string) + return m, id + } + } + return nil, "" +} + +// nestedObjectContext holds the navigation results for a nested ObjectType property: +// the ObjectType's PropertyTypes and the corresponding Object Properties from each +// WidgetObject instance. +type nestedObjectContext struct { + nestedObjType map[string]any + nestedPropTypes []any + nestedObjProps [][]any // Properties array per WidgetObject + objPropContainers []map[string]any // WidgetObject containers (for write-back) +} + +// resolveNestedObjectContext navigates from a matched PropertyType into its +// ValueType.ObjectType.PropertyTypes and finds the corresponding nested +// Object Properties via TypePointer matching. +func resolveNestedObjectContext(matchedPT map[string]any, matchedPTID string, objProps []any) *nestedObjectContext { + vt, ok := getMapField(matchedPT, "ValueType") + if !ok { + return nil + } + nestedObjType, ok := getMapField(vt, "ObjectType") + if !ok || nestedObjType == nil { + return nil + } + nestedPropTypes, ok := getArrayField(nestedObjType, "PropertyTypes") + if !ok { + return nil + } + + ctx := &nestedObjectContext{ + nestedObjType: nestedObjType, + nestedPropTypes: nestedPropTypes, + } + + // Find the corresponding Object WidgetProperty and its nested WidgetObjects + for _, prop := range objProps { + propMap, ok := prop.(map[string]any) + if !ok { + continue + } + tp, _ := propMap["TypePointer"].(string) + if tp != matchedPTID { + continue + } + val, ok := getMapField(propMap, "Value") + if !ok { + continue + } + objects, ok := getArrayField(val, "Objects") + if !ok { + continue + } + for _, obj := range objects { + objMap, ok := obj.(map[string]any) + if !ok { + continue + } + props, ok := getArrayField(objMap, "Properties") + if ok { + ctx.nestedObjProps = append(ctx.nestedObjProps, props) + ctx.objPropContainers = append(ctx.objPropContainers, objMap) + } + } + break + } + + return ctx +} + +// buildExemplarIndex scans PropertyTypes and returns: +// - existingKeys: set of PropertyKeys present +// - exemplars: map from ValueType.Type to the first index having that type +func buildExemplarIndex(propTypes []any) (existingKeys map[string]bool, exemplars map[string]int) { + existingKeys = make(map[string]bool) + exemplars = make(map[string]int) + for i, npt := range propTypes { + nptMap, ok := npt.(map[string]any) + if !ok { + continue + } + key, _ := nptMap["PropertyKey"].(string) + if key == "" { + continue + } + existingKeys[key] = true + + nvt, ok := getMapField(nptMap, "ValueType") + if ok { + vtType, _ := nvt["Type"].(string) + if vtType != "" { + if _, exists := exemplars[vtType]; !exists { + exemplars[vtType] = i + } + } + } + } + return +} + +// diffPropertyKeys computes the missing and stale property keys between an mpk +// definition's children and the existing PropertyType keys. +func diffPropertyKeys(mpkChildren []mpk.PropertyDef, existingKeys map[string]bool) (missing []mpk.PropertyDef, staleKeys []string) { + mpkChildKeys := make(map[string]bool, len(mpkChildren)) + for _, child := range mpkChildren { + mpkChildKeys[child.Key] = true + if !existingKeys[child.Key] { + missing = append(missing, child) + } + } + for key := range existingKeys { + if !mpkChildKeys[key] { + staleKeys = append(staleKeys, key) + } + } + return +} + +// removeNestedProperties removes stale PropertyTypes and their corresponding +// Properties from nested ObjectType structures. Returns updated slices. +func removeNestedProperties(nestedPropTypes []any, nestedObjProps [][]any, staleKeys []string) ([]any, [][]any) { + staleSet := make(map[string]bool, len(staleKeys)) + for _, key := range staleKeys { + staleSet[key] = true + } + + // Collect IDs of stale PropertyTypes + staleIDs := make(map[string]bool) + var filteredPropTypes []any + for _, npt := range nestedPropTypes { + nptMap, ok := npt.(map[string]any) + if !ok { + filteredPropTypes = append(filteredPropTypes, npt) + continue + } + key, _ := nptMap["PropertyKey"].(string) + if staleSet[key] { + id, _ := nptMap["$ID"].(string) + if id != "" { + staleIDs[id] = true + } + continue + } + filteredPropTypes = append(filteredPropTypes, npt) + } + + // Remove matching Properties from each WidgetObject + for i, nop := range nestedObjProps { + var filtered []any + for _, prop := range nop { + propMap, ok := prop.(map[string]any) + if !ok { + filtered = append(filtered, prop) + continue + } + tp, _ := propMap["TypePointer"].(string) + if staleIDs[tp] { + continue + } + filtered = append(filtered, prop) + } + nestedObjProps[i] = filtered + } + + return filteredPropTypes, nestedObjProps +}